// Copyright (c) 2024，D-Robotics.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// *** THIS FILE IS GENERATED - DO NOT EDIT ***
// See helper_file_generator.py for modifications


/***************************************************************************
 *
 * Copyright (c) 2015-2022 The Khronos Group Inc.
 * Copyright (c) 2015-2022 Valve Corporation
 * Copyright (c) 2015-2022 LunarG, Inc.
 * Copyright (c) 2015-2022 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Author: Mark Lobodzinski <mark@lunarg.com>
 * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
 * Author: Tobin Ehlis <tobine@google.com>
 * Author: Chris Forbes <chrisforbes@google.com>
 * Author: John Zulauf<jzulauf@lunarg.com>
 * Author: Tony Barbour <tony@lunarg.com>
 *
 ****************************************************************************/

#pragma once
#ifdef _MSC_VER
#pragma warning( disable : 4065 )
#endif

#include <string>
#include <vulkan/vulkan.h>


static inline const char* string_VkResult(VkResult input_value)
{
    switch (input_value)
    {
        case VK_ERROR_COMPRESSION_EXHAUSTED_EXT:
            return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT";
        case VK_ERROR_DEVICE_LOST:
            return "VK_ERROR_DEVICE_LOST";
        case VK_ERROR_EXTENSION_NOT_PRESENT:
            return "VK_ERROR_EXTENSION_NOT_PRESENT";
        case VK_ERROR_FEATURE_NOT_PRESENT:
            return "VK_ERROR_FEATURE_NOT_PRESENT";
        case VK_ERROR_FORMAT_NOT_SUPPORTED:
            return "VK_ERROR_FORMAT_NOT_SUPPORTED";
        case VK_ERROR_FRAGMENTATION:
            return "VK_ERROR_FRAGMENTATION";
        case VK_ERROR_FRAGMENTED_POOL:
            return "VK_ERROR_FRAGMENTED_POOL";
        case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
            return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
        case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
            return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
        case VK_ERROR_INCOMPATIBLE_DRIVER:
            return "VK_ERROR_INCOMPATIBLE_DRIVER";
        case VK_ERROR_INITIALIZATION_FAILED:
            return "VK_ERROR_INITIALIZATION_FAILED";
        case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
            return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
        case VK_ERROR_INVALID_EXTERNAL_HANDLE:
            return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
        case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS:
            return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
        case VK_ERROR_INVALID_SHADER_NV:
            return "VK_ERROR_INVALID_SHADER_NV";
        case VK_ERROR_LAYER_NOT_PRESENT:
            return "VK_ERROR_LAYER_NOT_PRESENT";
        case VK_ERROR_MEMORY_MAP_FAILED:
            return "VK_ERROR_MEMORY_MAP_FAILED";
        case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
            return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
        case VK_ERROR_NOT_PERMITTED_KHR:
            return "VK_ERROR_NOT_PERMITTED_KHR";
        case VK_ERROR_OUT_OF_DATE_KHR:
            return "VK_ERROR_OUT_OF_DATE_KHR";
        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
            return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
        case VK_ERROR_OUT_OF_HOST_MEMORY:
            return "VK_ERROR_OUT_OF_HOST_MEMORY";
        case VK_ERROR_OUT_OF_POOL_MEMORY:
            return "VK_ERROR_OUT_OF_POOL_MEMORY";
        case VK_ERROR_SURFACE_LOST_KHR:
            return "VK_ERROR_SURFACE_LOST_KHR";
        case VK_ERROR_TOO_MANY_OBJECTS:
            return "VK_ERROR_TOO_MANY_OBJECTS";
        case VK_ERROR_UNKNOWN:
            return "VK_ERROR_UNKNOWN";
        case VK_ERROR_VALIDATION_FAILED_EXT:
            return "VK_ERROR_VALIDATION_FAILED_EXT";
        case VK_EVENT_RESET:
            return "VK_EVENT_RESET";
        case VK_EVENT_SET:
            return "VK_EVENT_SET";
        case VK_INCOMPLETE:
            return "VK_INCOMPLETE";
        case VK_NOT_READY:
            return "VK_NOT_READY";
        case VK_OPERATION_DEFERRED_KHR:
            return "VK_OPERATION_DEFERRED_KHR";
        case VK_OPERATION_NOT_DEFERRED_KHR:
            return "VK_OPERATION_NOT_DEFERRED_KHR";
        case VK_PIPELINE_COMPILE_REQUIRED:
            return "VK_PIPELINE_COMPILE_REQUIRED";
        case VK_SUBOPTIMAL_KHR:
            return "VK_SUBOPTIMAL_KHR";
        case VK_SUCCESS:
            return "VK_SUCCESS";
        case VK_THREAD_DONE_KHR:
            return "VK_THREAD_DONE_KHR";
        case VK_THREAD_IDLE_KHR:
            return "VK_THREAD_IDLE_KHR";
        case VK_TIMEOUT:
            return "VK_TIMEOUT";
        default:
            return "Unhandled VkResult";
    }
}

static inline const char* string_VkStructureType(VkStructureType input_value)
{
    switch (input_value)
    {
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV";
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR";
        case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR";
        case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR";
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
            return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID";
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
            return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID";
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
            return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID";
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
            return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID";
        case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_APPLICATION_INFO:
            return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
            return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2";
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
            return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT";
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
            return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2";
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
            return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT";
        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
            return "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD";
        case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
            return "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV";
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
            return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO";
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
            return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO";
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
            return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO";
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
            return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO";
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
            return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR";
        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
            return "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO";
        case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
            return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO";
        case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
            return "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2";
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
            return "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA";
        case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
            return "VK_STRUCTURE_TYPE_BUFFER_COPY_2";
        case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
            return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO";
        case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
            return "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2";
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
            return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
            return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2";
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
            return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2";
        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO";
        case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
        case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT:
            return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT";
        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
            return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV";
        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
            return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV";
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO";
        case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
            return "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT";
        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR";
        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
            return "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR";
        case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
            return "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2";
        case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
            return "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2";
        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
            return "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM";
        case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
            return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET";
        case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
            return "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2";
        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
            return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2";
        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR";
        case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
            return "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX";
        case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
            return "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX";
        case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
            return "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX";
        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR";
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV";
        case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
            return "VK_STRUCTURE_TYPE_DEPENDENCY_INFO";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT";
        case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
            return "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS";
        case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
            return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS";
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
            return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD";
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
            return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT";
        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
            return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2";
        case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT";
        case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR";
        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
            return "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD";
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR";
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR";
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR";
        case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
            return "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT";
        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
        case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR";
        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
            return "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT";
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
            return "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT";
        case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
            return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO";
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV";
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV";
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
            return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES";
        case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
            return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES";
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
            return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID";
        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
            return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES";
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO";
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
            return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES";
        case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
            return "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR";
        case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
            return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2";
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
            return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3";
        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR";
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO";
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
            return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO";
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
            return "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV";
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
            return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV";
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
            return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV";
        case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
            return "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV";
        case VK_STRUCTURE_TYPE_GEOMETRY_NV:
            return "VK_STRUCTURE_TYPE_GEOMETRY_NV";
        case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
            return "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV";
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
            return "VK_STRUCTURE_TYPE_HDR_METADATA_EXT";
        case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
            return "VK_STRUCTURE_TYPE_IMAGE_BLIT_2";
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
            return "VK_STRUCTURE_TYPE_IMAGE_COPY_2";
        case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO";
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
            return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2";
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
            return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
            return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2";
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
            return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2";
        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
            return "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO";
        case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
            return "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2";
        case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
            return "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2";
        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
            return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX";
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
            return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX";
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            return "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID";
        case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
            return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR";
        case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
            return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA";
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
            return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR";
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
            return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT";
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV";
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
            return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR";
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
            return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV";
        case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
            return "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL";
        case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
            return "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK";
        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
            return "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK";
        case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
            return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
            return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO";
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
            return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
            return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
            return "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2";
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
            return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO";
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
            return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS";
        case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID";
        case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
            return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR";
        case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV:
            return "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV";
        case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
            return "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO";
        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
            return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2";
        case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
            return "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA";
        case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
            return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX";
        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
            return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE";
        case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
            return "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL";
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
            return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR";
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
            return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR";
        case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
            return "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL";
        case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
            return "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL";
        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR";
        case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
            return "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES";
        case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
            return "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD";
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR";
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR";
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR";
        case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD";
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
            return "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP";
        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
            return "VK_STRUCTURE_TYPE_PRESENT_ID_KHR";
        case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
            return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
            return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
        case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO";
        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
            return "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO";
        case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
            return "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL";
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV";
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV";
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR";
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR:
            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
            return "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV";
        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
            return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO";
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT";
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR";
        case VK_STRUCTURE_TYPE_RENDERING_INFO:
            return "VK_STRUCTURE_TYPE_RENDERING_INFO";
        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO";
        case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2";
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT";
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO";
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO";
        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT";
        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
            return "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM";
        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
            return "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2";
        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO";
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
            return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES";
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
            return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO";
        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
            return "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT";
        case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
            return "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX";
        case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR";
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR";
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA";
        case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO";
        case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO";
        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
            return "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO";
        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
            return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
            return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR";
        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
            return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2";
        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
            return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2";
        case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
            return "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP";
        case VK_STRUCTURE_TYPE_SUBMIT_INFO:
            return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
        case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
            return "VK_STRUCTURE_TYPE_SUBMIT_INFO_2";
        case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
            return "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO";
        case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
            return "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2";
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
            return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2";
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
            return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE";
        case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
            return "VK_STRUCTURE_TYPE_SUBPASS_END_INFO";
        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
            return "VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM";
        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
            return "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI";
        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT:
            return "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT";
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
            return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT";
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
            return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
            return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT";
        case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
            return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT";
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
            return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT";
        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
            return "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR";
        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
            return "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD";
        case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA:
            return "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA";
        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
            return "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD";
        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
            return "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO";
        case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT";
        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
            return "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT";
        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
            return "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT";
        case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
            return "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT";
        case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
            return "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
            return "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN";
        case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR";
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
            return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV";
        case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
            return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET";
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
            return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR";
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
            return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV";
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
            return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK";
        case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
        case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
            return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
        default:
            return "Unhandled VkStructureType";
    }
}

static inline const char* string_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_CACHE_HEADER_VERSION_ONE:
            return "VK_PIPELINE_CACHE_HEADER_VERSION_ONE";
        default:
            return "Unhandled VkPipelineCacheHeaderVersion";
    }
}

static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value)
{
    switch (input_value)
    {
        case VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR:
            return "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR";
        case VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR:
            return "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
        case VK_ACCESS_COLOR_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT";
        case VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
            return "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
        case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT:
            return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT";
        case VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV:
            return "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV";
        case VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV:
            return "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV";
        case VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT:
            return "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT";
        case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
        case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
            return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
        case VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
            return "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
        case VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
            return "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
        case VK_ACCESS_HOST_READ_BIT:
            return "VK_ACCESS_HOST_READ_BIT";
        case VK_ACCESS_HOST_WRITE_BIT:
            return "VK_ACCESS_HOST_WRITE_BIT";
        case VK_ACCESS_INDEX_READ_BIT:
            return "VK_ACCESS_INDEX_READ_BIT";
        case VK_ACCESS_INDIRECT_COMMAND_READ_BIT:
            return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT";
        case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT";
        case VK_ACCESS_MEMORY_READ_BIT:
            return "VK_ACCESS_MEMORY_READ_BIT";
        case VK_ACCESS_MEMORY_WRITE_BIT:
            return "VK_ACCESS_MEMORY_WRITE_BIT";
        case VK_ACCESS_NONE:
            return "VK_ACCESS_NONE";
        case VK_ACCESS_SHADER_READ_BIT:
            return "VK_ACCESS_SHADER_READ_BIT";
        case VK_ACCESS_SHADER_WRITE_BIT:
            return "VK_ACCESS_SHADER_WRITE_BIT";
        case VK_ACCESS_TRANSFER_READ_BIT:
            return "VK_ACCESS_TRANSFER_READ_BIT";
        case VK_ACCESS_TRANSFER_WRITE_BIT:
            return "VK_ACCESS_TRANSFER_WRITE_BIT";
        case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
            return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
        case VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
            return "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
        case VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
            return "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
        case VK_ACCESS_UNIFORM_READ_BIT:
            return "VK_ACCESS_UNIFORM_READ_BIT";
        case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT:
            return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT";
        default:
            return "Unhandled VkAccessFlagBits";
    }
}

static inline std::string string_VkAccessFlags(VkAccessFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkAccessFlagBits(static_cast<VkAccessFlagBits>(0)));
    return ret;
}

static inline const char* string_VkImageLayout(VkImageLayout input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
            return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL";
        case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
            return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
            return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL";
        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
            return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL";
        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
            return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL";
        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
            return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL";
        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
            return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
            return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
        case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
            return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
        case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
            return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
        case VK_IMAGE_LAYOUT_GENERAL:
            return "VK_IMAGE_LAYOUT_GENERAL";
        case VK_IMAGE_LAYOUT_PREINITIALIZED:
            return "VK_IMAGE_LAYOUT_PREINITIALIZED";
        case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
            return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
        case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL:
            return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL";
        case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
            return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
        case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
            return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
        case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
            return "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL";
        case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
            return "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL";
        case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
            return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
        case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
            return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
        case VK_IMAGE_LAYOUT_UNDEFINED:
            return "VK_IMAGE_LAYOUT_UNDEFINED";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR:
            return "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkImageLayout";
    }
}

static inline const char* string_VkImageAspectFlagBits(VkImageAspectFlagBits input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_ASPECT_COLOR_BIT:
            return "VK_IMAGE_ASPECT_COLOR_BIT";
        case VK_IMAGE_ASPECT_DEPTH_BIT:
            return "VK_IMAGE_ASPECT_DEPTH_BIT";
        case VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT:
            return "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT";
        case VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT:
            return "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT";
        case VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT:
            return "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT";
        case VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT:
            return "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT";
        case VK_IMAGE_ASPECT_METADATA_BIT:
            return "VK_IMAGE_ASPECT_METADATA_BIT";
        case VK_IMAGE_ASPECT_NONE:
            return "VK_IMAGE_ASPECT_NONE";
        case VK_IMAGE_ASPECT_PLANE_0_BIT:
            return "VK_IMAGE_ASPECT_PLANE_0_BIT";
        case VK_IMAGE_ASPECT_PLANE_1_BIT:
            return "VK_IMAGE_ASPECT_PLANE_1_BIT";
        case VK_IMAGE_ASPECT_PLANE_2_BIT:
            return "VK_IMAGE_ASPECT_PLANE_2_BIT";
        case VK_IMAGE_ASPECT_STENCIL_BIT:
            return "VK_IMAGE_ASPECT_STENCIL_BIT";
        default:
            return "Unhandled VkImageAspectFlagBits";
    }
}

static inline std::string string_VkImageAspectFlags(VkImageAspectFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkImageAspectFlagBits(static_cast<VkImageAspectFlagBits>(0)));
    return ret;
}

static inline const char* string_VkObjectType(VkObjectType input_value)
{
    switch (input_value)
    {
        case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR:
            return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR";
        case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV:
            return "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV";
        case VK_OBJECT_TYPE_BUFFER:
            return "VK_OBJECT_TYPE_BUFFER";
        case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA:
            return "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA";
        case VK_OBJECT_TYPE_BUFFER_VIEW:
            return "VK_OBJECT_TYPE_BUFFER_VIEW";
        case VK_OBJECT_TYPE_COMMAND_BUFFER:
            return "VK_OBJECT_TYPE_COMMAND_BUFFER";
        case VK_OBJECT_TYPE_COMMAND_POOL:
            return "VK_OBJECT_TYPE_COMMAND_POOL";
        case VK_OBJECT_TYPE_CU_FUNCTION_NVX:
            return "VK_OBJECT_TYPE_CU_FUNCTION_NVX";
        case VK_OBJECT_TYPE_CU_MODULE_NVX:
            return "VK_OBJECT_TYPE_CU_MODULE_NVX";
        case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
            return "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT";
        case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
            return "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT";
        case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR:
            return "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR";
        case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
            return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
        case VK_OBJECT_TYPE_DESCRIPTOR_SET:
            return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
            return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
        case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE:
            return "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE";
        case VK_OBJECT_TYPE_DEVICE:
            return "VK_OBJECT_TYPE_DEVICE";
        case VK_OBJECT_TYPE_DEVICE_MEMORY:
            return "VK_OBJECT_TYPE_DEVICE_MEMORY";
        case VK_OBJECT_TYPE_DISPLAY_KHR:
            return "VK_OBJECT_TYPE_DISPLAY_KHR";
        case VK_OBJECT_TYPE_DISPLAY_MODE_KHR:
            return "VK_OBJECT_TYPE_DISPLAY_MODE_KHR";
        case VK_OBJECT_TYPE_EVENT:
            return "VK_OBJECT_TYPE_EVENT";
        case VK_OBJECT_TYPE_FENCE:
            return "VK_OBJECT_TYPE_FENCE";
        case VK_OBJECT_TYPE_FRAMEBUFFER:
            return "VK_OBJECT_TYPE_FRAMEBUFFER";
        case VK_OBJECT_TYPE_IMAGE:
            return "VK_OBJECT_TYPE_IMAGE";
        case VK_OBJECT_TYPE_IMAGE_VIEW:
            return "VK_OBJECT_TYPE_IMAGE_VIEW";
        case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV:
            return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV";
        case VK_OBJECT_TYPE_INSTANCE:
            return "VK_OBJECT_TYPE_INSTANCE";
        case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL:
            return "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL";
        case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
            return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
        case VK_OBJECT_TYPE_PIPELINE:
            return "VK_OBJECT_TYPE_PIPELINE";
        case VK_OBJECT_TYPE_PIPELINE_CACHE:
            return "VK_OBJECT_TYPE_PIPELINE_CACHE";
        case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
            return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
        case VK_OBJECT_TYPE_PRIVATE_DATA_SLOT:
            return "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT";
        case VK_OBJECT_TYPE_QUERY_POOL:
            return "VK_OBJECT_TYPE_QUERY_POOL";
        case VK_OBJECT_TYPE_QUEUE:
            return "VK_OBJECT_TYPE_QUEUE";
        case VK_OBJECT_TYPE_RENDER_PASS:
            return "VK_OBJECT_TYPE_RENDER_PASS";
        case VK_OBJECT_TYPE_SAMPLER:
            return "VK_OBJECT_TYPE_SAMPLER";
        case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION:
            return "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION";
        case VK_OBJECT_TYPE_SEMAPHORE:
            return "VK_OBJECT_TYPE_SEMAPHORE";
        case VK_OBJECT_TYPE_SHADER_MODULE:
            return "VK_OBJECT_TYPE_SHADER_MODULE";
        case VK_OBJECT_TYPE_SURFACE_KHR:
            return "VK_OBJECT_TYPE_SURFACE_KHR";
        case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
            return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
        case VK_OBJECT_TYPE_UNKNOWN:
            return "VK_OBJECT_TYPE_UNKNOWN";
        case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT:
            return "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_OBJECT_TYPE_VIDEO_SESSION_KHR:
            return "VK_OBJECT_TYPE_VIDEO_SESSION_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR:
            return "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR";
#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR:
            return "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR:
            return "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR:
            return "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkFormatFeatureFlagBits";
    }
}

static inline std::string string_VkFormatFeatureFlags(VkFormatFeatureFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkFormatFeatureFlagBits(static_cast<VkFormatFeatureFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkFormatFeatureFlagBits(static_cast<VkFormatFeatureFlagBits>(0)));
    return ret;
}

static inline const char* string_VkImageCreateFlagBits(VkImageCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT:
            return "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT";
        case VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT:
            return "VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT";
        case VK_IMAGE_CREATE_ALIAS_BIT:
            return "VK_IMAGE_CREATE_ALIAS_BIT";
        case VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT:
            return "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT";
        case VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV:
            return "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV";
        case VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT:
            return "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT";
        case VK_IMAGE_CREATE_DISJOINT_BIT:
            return "VK_IMAGE_CREATE_DISJOINT_BIT";
        case VK_IMAGE_CREATE_EXTENDED_USAGE_BIT:
            return "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT";
        case VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM:
            return "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM";
        case VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
            return "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
        case VK_IMAGE_CREATE_PROTECTED_BIT:
            return "VK_IMAGE_CREATE_PROTECTED_BIT";
        case VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT:
            return "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT";
        case VK_IMAGE_CREATE_SPARSE_ALIASED_BIT:
            return "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT";
        case VK_IMAGE_CREATE_SPARSE_BINDING_BIT:
            return "VK_IMAGE_CREATE_SPARSE_BINDING_BIT";
        case VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT:
            return "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT";
        case VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT:
            return "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT";
        case VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT:
            return "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT";
        default:
            return "Unhandled VkImageCreateFlagBits";
    }
}

static inline std::string string_VkImageCreateFlags(VkImageCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkImageCreateFlagBits(static_cast<VkImageCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkImageCreateFlagBits(static_cast<VkImageCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSampleCountFlagBits(VkSampleCountFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SAMPLE_COUNT_16_BIT:
            return "VK_SAMPLE_COUNT_16_BIT";
        case VK_SAMPLE_COUNT_1_BIT:
            return "VK_SAMPLE_COUNT_1_BIT";
        case VK_SAMPLE_COUNT_2_BIT:
            return "VK_SAMPLE_COUNT_2_BIT";
        case VK_SAMPLE_COUNT_32_BIT:
            return "VK_SAMPLE_COUNT_32_BIT";
        case VK_SAMPLE_COUNT_4_BIT:
            return "VK_SAMPLE_COUNT_4_BIT";
        case VK_SAMPLE_COUNT_64_BIT:
            return "VK_SAMPLE_COUNT_64_BIT";
        case VK_SAMPLE_COUNT_8_BIT:
            return "VK_SAMPLE_COUNT_8_BIT";
        default:
            return "Unhandled VkSampleCountFlagBits";
    }
}

static inline std::string string_VkSampleCountFlags(VkSampleCountFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSampleCountFlagBits(static_cast<VkSampleCountFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSampleCountFlagBits(static_cast<VkSampleCountFlagBits>(0)));
    return ret;
}

static inline const char* string_VkImageTiling(VkImageTiling input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT:
            return "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT";
        case VK_IMAGE_TILING_LINEAR:
            return "VK_IMAGE_TILING_LINEAR";
        case VK_IMAGE_TILING_OPTIMAL:
            return "VK_IMAGE_TILING_OPTIMAL";
        default:
            return "Unhandled VkImageTiling";
    }
}

static inline const char* string_VkImageType(VkImageType input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_TYPE_1D:
            return "VK_IMAGE_TYPE_1D";
        case VK_IMAGE_TYPE_2D:
            return "VK_IMAGE_TYPE_2D";
        case VK_IMAGE_TYPE_3D:
            return "VK_IMAGE_TYPE_3D";
        default:
            return "Unhandled VkImageType";
    }
}

static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
            return "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
        case VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT:
            return "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT";
        case VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT:
            return "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT";
        case VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
            return "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT:
            return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
        case VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI:
            return "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI";
        case VK_IMAGE_USAGE_SAMPLED_BIT:
            return "VK_IMAGE_USAGE_SAMPLED_BIT";
        case VK_IMAGE_USAGE_STORAGE_BIT:
            return "VK_IMAGE_USAGE_STORAGE_BIT";
        case VK_IMAGE_USAGE_TRANSFER_DST_BIT:
            return "VK_IMAGE_USAGE_TRANSFER_DST_BIT";
        case VK_IMAGE_USAGE_TRANSFER_SRC_BIT:
            return "VK_IMAGE_USAGE_TRANSFER_SRC_BIT";
        case VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT:
            return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR:
            return "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR:
            return "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR:
            return "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR:
            return "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR:
            return "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR:
            return "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkImageUsageFlagBits";
    }
}

static inline std::string string_VkImageUsageFlags(VkImageUsageFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkImageUsageFlagBits(static_cast<VkImageUsageFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkImageUsageFlagBits(static_cast<VkImageUsageFlagBits>(0)));
    return ret;
}

static inline const char* string_VkInstanceCreateFlagBits(VkInstanceCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR:
            return "VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR";
        default:
            return "Unhandled VkInstanceCreateFlagBits";
    }
}

static inline std::string string_VkInstanceCreateFlags(VkInstanceCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkInstanceCreateFlagBits(static_cast<VkInstanceCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkInstanceCreateFlagBits(static_cast<VkInstanceCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input_value)
{
    switch (input_value)
    {
        case VK_MEMORY_HEAP_DEVICE_LOCAL_BIT:
            return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT";
        case VK_MEMORY_HEAP_MULTI_INSTANCE_BIT:
            return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT";
        default:
            return "Unhandled VkMemoryHeapFlagBits";
    }
}

static inline std::string string_VkMemoryHeapFlags(VkMemoryHeapFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkMemoryHeapFlagBits(static_cast<VkMemoryHeapFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkMemoryHeapFlagBits(static_cast<VkMemoryHeapFlagBits>(0)));
    return ret;
}

static inline const char* string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits input_value)
{
    switch (input_value)
    {
        case VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD:
            return "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD";
        case VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT:
            return "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT";
        case VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD:
            return "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD";
        case VK_MEMORY_PROPERTY_HOST_CACHED_BIT:
            return "VK_MEMORY_PROPERTY_HOST_CACHED_BIT";
        case VK_MEMORY_PROPERTY_HOST_COHERENT_BIT:
            return "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT";
        case VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT:
            return "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT";
        case VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT:
            return "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT";
        case VK_MEMORY_PROPERTY_PROTECTED_BIT:
            return "VK_MEMORY_PROPERTY_PROTECTED_BIT";
        case VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV:
            return "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV";
        default:
            return "Unhandled VkMemoryPropertyFlagBits";
    }
}

static inline std::string string_VkMemoryPropertyFlags(VkMemoryPropertyFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkMemoryPropertyFlagBits(static_cast<VkMemoryPropertyFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkMemoryPropertyFlagBits(static_cast<VkMemoryPropertyFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPhysicalDeviceType(VkPhysicalDeviceType input_value)
{
    switch (input_value)
    {
        case VK_PHYSICAL_DEVICE_TYPE_CPU:
            return "VK_PHYSICAL_DEVICE_TYPE_CPU";
        case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
            return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
        case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
            return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
            return "VK_PHYSICAL_DEVICE_TYPE_OTHER";
        case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
            return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
        default:
            return "Unhandled VkPhysicalDeviceType";
    }
}

static inline const char* string_VkQueueFlagBits(VkQueueFlagBits input_value)
{
    switch (input_value)
    {
        case VK_QUEUE_COMPUTE_BIT:
            return "VK_QUEUE_COMPUTE_BIT";
        case VK_QUEUE_GRAPHICS_BIT:
            return "VK_QUEUE_GRAPHICS_BIT";
        case VK_QUEUE_PROTECTED_BIT:
            return "VK_QUEUE_PROTECTED_BIT";
        case VK_QUEUE_SPARSE_BINDING_BIT:
            return "VK_QUEUE_SPARSE_BINDING_BIT";
        case VK_QUEUE_TRANSFER_BIT:
            return "VK_QUEUE_TRANSFER_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_QUEUE_VIDEO_DECODE_BIT_KHR:
            return "VK_QUEUE_VIDEO_DECODE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_QUEUE_VIDEO_ENCODE_BIT_KHR:
            return "VK_QUEUE_VIDEO_ENCODE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkQueueFlagBits";
    }
}

static inline std::string string_VkQueueFlags(VkQueueFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkQueueFlagBits(static_cast<VkQueueFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkQueueFlagBits(static_cast<VkQueueFlagBits>(0)));
    return ret;
}

static inline const char* string_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT:
            return "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT";
        default:
            return "Unhandled VkDeviceQueueCreateFlagBits";
    }
}

static inline std::string string_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDeviceQueueCreateFlagBits(static_cast<VkDeviceQueueCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDeviceQueueCreateFlagBits(static_cast<VkDeviceQueueCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPipelineStageFlagBits(VkPipelineStageFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR:
            return "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
        case VK_PIPELINE_STAGE_ALL_COMMANDS_BIT:
            return "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT";
        case VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT:
            return "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT";
        case VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT:
            return "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT";
        case VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT:
            return "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT";
        case VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV:
            return "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV";
        case VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT:
            return "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT";
        case VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT:
            return "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT";
        case VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
            return "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT";
        case VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT:
            return "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT";
        case VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
            return "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
        case VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT:
            return "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT";
        case VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
            return "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        case VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT:
            return "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT";
        case VK_PIPELINE_STAGE_HOST_BIT:
            return "VK_PIPELINE_STAGE_HOST_BIT";
        case VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT:
            return "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT";
        case VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV:
            return "VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV";
        case VK_PIPELINE_STAGE_NONE:
            return "VK_PIPELINE_STAGE_NONE";
        case VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR:
            return "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR";
        case VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV:
            return "VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV";
        case VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT:
            return "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT";
        case VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT:
            return "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT";
        case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT:
            return "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT";
        case VK_PIPELINE_STAGE_TRANSFER_BIT:
            return "VK_PIPELINE_STAGE_TRANSFER_BIT";
        case VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT:
            return "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT";
        case VK_PIPELINE_STAGE_VERTEX_INPUT_BIT:
            return "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT";
        case VK_PIPELINE_STAGE_VERTEX_SHADER_BIT:
            return "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT";
        default:
            return "Unhandled VkPipelineStageFlagBits";
    }
}

static inline std::string string_VkPipelineStageFlags(VkPipelineStageFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineStageFlagBits(static_cast<VkPipelineStageFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineStageFlagBits(static_cast<VkPipelineStageFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
            return "VK_SPARSE_MEMORY_BIND_METADATA_BIT";
        default:
            return "Unhandled VkSparseMemoryBindFlagBits";
    }
}

static inline std::string string_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSparseMemoryBindFlagBits(static_cast<VkSparseMemoryBindFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSparseImageFormatFlagBits(VkSparseImageFormatFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT:
            return "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT";
        case VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT:
            return "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT";
        case VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT:
            return "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT";
        default:
            return "Unhandled VkSparseImageFormatFlagBits";
    }
}

static inline std::string string_VkSparseImageFormatFlags(VkSparseImageFormatFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSparseImageFormatFlagBits(static_cast<VkSparseImageFormatFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSparseImageFormatFlagBits(static_cast<VkSparseImageFormatFlagBits>(0)));
    return ret;
}

static inline const char* string_VkFenceCreateFlagBits(VkFenceCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_FENCE_CREATE_SIGNALED_BIT:
            return "VK_FENCE_CREATE_SIGNALED_BIT";
        default:
            return "Unhandled VkFenceCreateFlagBits";
    }
}

static inline std::string string_VkFenceCreateFlags(VkFenceCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkFenceCreateFlagBits(static_cast<VkFenceCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkFenceCreateFlagBits(static_cast<VkFenceCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkEventCreateFlagBits(VkEventCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_EVENT_CREATE_DEVICE_ONLY_BIT:
            return "VK_EVENT_CREATE_DEVICE_ONLY_BIT";
        default:
            return "Unhandled VkEventCreateFlagBits";
    }
}

static inline std::string string_VkEventCreateFlags(VkEventCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkEventCreateFlagBits(static_cast<VkEventCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkEventCreateFlagBits(static_cast<VkEventCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits input_value)
{
    switch (input_value)
    {
        case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT";
        case VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT:
            return "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT";
        default:
            return "Unhandled VkQueryPipelineStatisticFlagBits";
    }
}

static inline std::string string_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkQueryPipelineStatisticFlagBits(static_cast<VkQueryPipelineStatisticFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkQueryPipelineStatisticFlagBits(static_cast<VkQueryPipelineStatisticFlagBits>(0)));
    return ret;
}

static inline const char* string_VkQueryType(VkQueryType input_value)
{
    switch (input_value)
    {
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR:
            return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR";
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV:
            return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV";
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR:
            return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR";
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR:
            return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR";
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR:
            return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR";
        case VK_QUERY_TYPE_OCCLUSION:
            return "VK_QUERY_TYPE_OCCLUSION";
        case VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL:
            return "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL";
        case VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR:
            return "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR";
        case VK_QUERY_TYPE_PIPELINE_STATISTICS:
            return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
        case VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT:
            return "VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR:
            return "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        case VK_QUERY_TYPE_TIMESTAMP:
            return "VK_QUERY_TYPE_TIMESTAMP";
        case VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT:
            return "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR:
            return "VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkQueryType";
    }
}

static inline const char* string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value)
{
    switch (input_value)
    {
        case VK_QUERY_RESULT_64_BIT:
            return "VK_QUERY_RESULT_64_BIT";
        case VK_QUERY_RESULT_PARTIAL_BIT:
            return "VK_QUERY_RESULT_PARTIAL_BIT";
        case VK_QUERY_RESULT_WAIT_BIT:
            return "VK_QUERY_RESULT_WAIT_BIT";
        case VK_QUERY_RESULT_WITH_AVAILABILITY_BIT:
            return "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_QUERY_RESULT_WITH_STATUS_BIT_KHR:
            return "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkQueryResultFlagBits";
    }
}

static inline std::string string_VkQueryResultFlags(VkQueryResultFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkQueryResultFlagBits(static_cast<VkQueryResultFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkQueryResultFlagBits(static_cast<VkQueryResultFlagBits>(0)));
    return ret;
}

static inline const char* string_VkBufferCreateFlagBits(VkBufferCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT:
            return "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
        case VK_BUFFER_CREATE_PROTECTED_BIT:
            return "VK_BUFFER_CREATE_PROTECTED_BIT";
        case VK_BUFFER_CREATE_SPARSE_ALIASED_BIT:
            return "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT";
        case VK_BUFFER_CREATE_SPARSE_BINDING_BIT:
            return "VK_BUFFER_CREATE_SPARSE_BINDING_BIT";
        case VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT:
            return "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT";
        default:
            return "Unhandled VkBufferCreateFlagBits";
    }
}

static inline std::string string_VkBufferCreateFlags(VkBufferCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkBufferCreateFlagBits(static_cast<VkBufferCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkBufferCreateFlagBits(static_cast<VkBufferCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits input_value)
{
    switch (input_value)
    {
        case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR:
            return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
        case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR:
            return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
        case VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT:
            return "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT";
        case VK_BUFFER_USAGE_INDEX_BUFFER_BIT:
            return "VK_BUFFER_USAGE_INDEX_BUFFER_BIT";
        case VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT:
            return "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT";
        case VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR:
            return "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR";
        case VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT:
            return "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT";
        case VK_BUFFER_USAGE_STORAGE_BUFFER_BIT:
            return "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT";
        case VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT:
            return "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT";
        case VK_BUFFER_USAGE_TRANSFER_DST_BIT:
            return "VK_BUFFER_USAGE_TRANSFER_DST_BIT";
        case VK_BUFFER_USAGE_TRANSFER_SRC_BIT:
            return "VK_BUFFER_USAGE_TRANSFER_SRC_BIT";
        case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT:
            return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
        case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT:
            return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
        case VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT:
            return "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT";
        case VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT:
            return "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT";
        case VK_BUFFER_USAGE_VERTEX_BUFFER_BIT:
            return "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR:
            return "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR:
            return "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR:
            return "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR:
            return "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkBufferUsageFlagBits";
    }
}

static inline std::string string_VkBufferUsageFlags(VkBufferUsageFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkBufferUsageFlagBits(static_cast<VkBufferUsageFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkBufferUsageFlagBits(static_cast<VkBufferUsageFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSharingMode(VkSharingMode input_value)
{
    switch (input_value)
    {
        case VK_SHARING_MODE_CONCURRENT:
            return "VK_SHARING_MODE_CONCURRENT";
        case VK_SHARING_MODE_EXCLUSIVE:
            return "VK_SHARING_MODE_EXCLUSIVE";
        default:
            return "Unhandled VkSharingMode";
    }
}

static inline const char* string_VkComponentSwizzle(VkComponentSwizzle input_value)
{
    switch (input_value)
    {
        case VK_COMPONENT_SWIZZLE_A:
            return "VK_COMPONENT_SWIZZLE_A";
        case VK_COMPONENT_SWIZZLE_B:
            return "VK_COMPONENT_SWIZZLE_B";
        case VK_COMPONENT_SWIZZLE_G:
            return "VK_COMPONENT_SWIZZLE_G";
        case VK_COMPONENT_SWIZZLE_IDENTITY:
            return "VK_COMPONENT_SWIZZLE_IDENTITY";
        case VK_COMPONENT_SWIZZLE_ONE:
            return "VK_COMPONENT_SWIZZLE_ONE";
        case VK_COMPONENT_SWIZZLE_R:
            return "VK_COMPONENT_SWIZZLE_R";
        case VK_COMPONENT_SWIZZLE_ZERO:
            return "VK_COMPONENT_SWIZZLE_ZERO";
        default:
            return "Unhandled VkComponentSwizzle";
    }
}

static inline const char* string_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT:
            return "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT";
        case VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT:
            return "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT";
        default:
            return "Unhandled VkImageViewCreateFlagBits";
    }
}

static inline std::string string_VkImageViewCreateFlags(VkImageViewCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkImageViewCreateFlagBits(static_cast<VkImageViewCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkImageViewCreateFlagBits(static_cast<VkImageViewCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkImageViewType(VkImageViewType input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_VIEW_TYPE_1D:
            return "VK_IMAGE_VIEW_TYPE_1D";
        case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
            return "VK_IMAGE_VIEW_TYPE_1D_ARRAY";
        case VK_IMAGE_VIEW_TYPE_2D:
            return "VK_IMAGE_VIEW_TYPE_2D";
        case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
            return "VK_IMAGE_VIEW_TYPE_2D_ARRAY";
        case VK_IMAGE_VIEW_TYPE_3D:
            return "VK_IMAGE_VIEW_TYPE_3D";
        case VK_IMAGE_VIEW_TYPE_CUBE:
            return "VK_IMAGE_VIEW_TYPE_CUBE";
        case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
            return "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY";
        default:
            return "Unhandled VkImageViewType";
    }
}

static inline const char* string_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT:
            return "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT";
        default:
            return "Unhandled VkPipelineCacheCreateFlagBits";
    }
}

static inline std::string string_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineCacheCreateFlagBits(static_cast<VkPipelineCacheCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineCacheCreateFlagBits(static_cast<VkPipelineCacheCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkBlendFactor(VkBlendFactor input_value)
{
    switch (input_value)
    {
        case VK_BLEND_FACTOR_CONSTANT_ALPHA:
            return "VK_BLEND_FACTOR_CONSTANT_ALPHA";
        case VK_BLEND_FACTOR_CONSTANT_COLOR:
            return "VK_BLEND_FACTOR_CONSTANT_COLOR";
        case VK_BLEND_FACTOR_DST_ALPHA:
            return "VK_BLEND_FACTOR_DST_ALPHA";
        case VK_BLEND_FACTOR_DST_COLOR:
            return "VK_BLEND_FACTOR_DST_COLOR";
        case VK_BLEND_FACTOR_ONE:
            return "VK_BLEND_FACTOR_ONE";
        case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
            return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA";
        case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
            return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR";
        case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
            return "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA";
        case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
            return "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR";
        case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA:
            return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA";
        case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR:
            return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR";
        case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
            return "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA";
        case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
            return "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR";
        case VK_BLEND_FACTOR_SRC1_ALPHA:
            return "VK_BLEND_FACTOR_SRC1_ALPHA";
        case VK_BLEND_FACTOR_SRC1_COLOR:
            return "VK_BLEND_FACTOR_SRC1_COLOR";
        case VK_BLEND_FACTOR_SRC_ALPHA:
            return "VK_BLEND_FACTOR_SRC_ALPHA";
        case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
            return "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE";
        case VK_BLEND_FACTOR_SRC_COLOR:
            return "VK_BLEND_FACTOR_SRC_COLOR";
        case VK_BLEND_FACTOR_ZERO:
            return "VK_BLEND_FACTOR_ZERO";
        default:
            return "Unhandled VkBlendFactor";
    }
}

static inline const char* string_VkBlendOp(VkBlendOp input_value)
{
    switch (input_value)
    {
        case VK_BLEND_OP_ADD:
            return "VK_BLEND_OP_ADD";
        case VK_BLEND_OP_BLUE_EXT:
            return "VK_BLEND_OP_BLUE_EXT";
        case VK_BLEND_OP_COLORBURN_EXT:
            return "VK_BLEND_OP_COLORBURN_EXT";
        case VK_BLEND_OP_COLORDODGE_EXT:
            return "VK_BLEND_OP_COLORDODGE_EXT";
        case VK_BLEND_OP_CONTRAST_EXT:
            return "VK_BLEND_OP_CONTRAST_EXT";
        case VK_BLEND_OP_DARKEN_EXT:
            return "VK_BLEND_OP_DARKEN_EXT";
        case VK_BLEND_OP_DIFFERENCE_EXT:
            return "VK_BLEND_OP_DIFFERENCE_EXT";
        case VK_BLEND_OP_DST_ATOP_EXT:
            return "VK_BLEND_OP_DST_ATOP_EXT";
        case VK_BLEND_OP_DST_EXT:
            return "VK_BLEND_OP_DST_EXT";
        case VK_BLEND_OP_DST_IN_EXT:
            return "VK_BLEND_OP_DST_IN_EXT";
        case VK_BLEND_OP_DST_OUT_EXT:
            return "VK_BLEND_OP_DST_OUT_EXT";
        case VK_BLEND_OP_DST_OVER_EXT:
            return "VK_BLEND_OP_DST_OVER_EXT";
        case VK_BLEND_OP_EXCLUSION_EXT:
            return "VK_BLEND_OP_EXCLUSION_EXT";
        case VK_BLEND_OP_GREEN_EXT:
            return "VK_BLEND_OP_GREEN_EXT";
        case VK_BLEND_OP_HARDLIGHT_EXT:
            return "VK_BLEND_OP_HARDLIGHT_EXT";
        case VK_BLEND_OP_HARDMIX_EXT:
            return "VK_BLEND_OP_HARDMIX_EXT";
        case VK_BLEND_OP_HSL_COLOR_EXT:
            return "VK_BLEND_OP_HSL_COLOR_EXT";
        case VK_BLEND_OP_HSL_HUE_EXT:
            return "VK_BLEND_OP_HSL_HUE_EXT";
        case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
            return "VK_BLEND_OP_HSL_LUMINOSITY_EXT";
        case VK_BLEND_OP_HSL_SATURATION_EXT:
            return "VK_BLEND_OP_HSL_SATURATION_EXT";
        case VK_BLEND_OP_INVERT_EXT:
            return "VK_BLEND_OP_INVERT_EXT";
        case VK_BLEND_OP_INVERT_OVG_EXT:
            return "VK_BLEND_OP_INVERT_OVG_EXT";
        case VK_BLEND_OP_INVERT_RGB_EXT:
            return "VK_BLEND_OP_INVERT_RGB_EXT";
        case VK_BLEND_OP_LIGHTEN_EXT:
            return "VK_BLEND_OP_LIGHTEN_EXT";
        case VK_BLEND_OP_LINEARBURN_EXT:
            return "VK_BLEND_OP_LINEARBURN_EXT";
        case VK_BLEND_OP_LINEARDODGE_EXT:
            return "VK_BLEND_OP_LINEARDODGE_EXT";
        case VK_BLEND_OP_LINEARLIGHT_EXT:
            return "VK_BLEND_OP_LINEARLIGHT_EXT";
        case VK_BLEND_OP_MAX:
            return "VK_BLEND_OP_MAX";
        case VK_BLEND_OP_MIN:
            return "VK_BLEND_OP_MIN";
        case VK_BLEND_OP_MINUS_CLAMPED_EXT:
            return "VK_BLEND_OP_MINUS_CLAMPED_EXT";
        case VK_BLEND_OP_MINUS_EXT:
            return "VK_BLEND_OP_MINUS_EXT";
        case VK_BLEND_OP_MULTIPLY_EXT:
            return "VK_BLEND_OP_MULTIPLY_EXT";
        case VK_BLEND_OP_OVERLAY_EXT:
            return "VK_BLEND_OP_OVERLAY_EXT";
        case VK_BLEND_OP_PINLIGHT_EXT:
            return "VK_BLEND_OP_PINLIGHT_EXT";
        case VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT:
            return "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT";
        case VK_BLEND_OP_PLUS_CLAMPED_EXT:
            return "VK_BLEND_OP_PLUS_CLAMPED_EXT";
        case VK_BLEND_OP_PLUS_DARKER_EXT:
            return "VK_BLEND_OP_PLUS_DARKER_EXT";
        case VK_BLEND_OP_PLUS_EXT:
            return "VK_BLEND_OP_PLUS_EXT";
        case VK_BLEND_OP_RED_EXT:
            return "VK_BLEND_OP_RED_EXT";
        case VK_BLEND_OP_REVERSE_SUBTRACT:
            return "VK_BLEND_OP_REVERSE_SUBTRACT";
        case VK_BLEND_OP_SCREEN_EXT:
            return "VK_BLEND_OP_SCREEN_EXT";
        case VK_BLEND_OP_SOFTLIGHT_EXT:
            return "VK_BLEND_OP_SOFTLIGHT_EXT";
        case VK_BLEND_OP_SRC_ATOP_EXT:
            return "VK_BLEND_OP_SRC_ATOP_EXT";
        case VK_BLEND_OP_SRC_EXT:
            return "VK_BLEND_OP_SRC_EXT";
        case VK_BLEND_OP_SRC_IN_EXT:
            return "VK_BLEND_OP_SRC_IN_EXT";
        case VK_BLEND_OP_SRC_OUT_EXT:
            return "VK_BLEND_OP_SRC_OUT_EXT";
        case VK_BLEND_OP_SRC_OVER_EXT:
            return "VK_BLEND_OP_SRC_OVER_EXT";
        case VK_BLEND_OP_SUBTRACT:
            return "VK_BLEND_OP_SUBTRACT";
        case VK_BLEND_OP_VIVIDLIGHT_EXT:
            return "VK_BLEND_OP_VIVIDLIGHT_EXT";
        case VK_BLEND_OP_XOR_EXT:
            return "VK_BLEND_OP_XOR_EXT";
        case VK_BLEND_OP_ZERO_EXT:
            return "VK_BLEND_OP_ZERO_EXT";
        default:
            return "Unhandled VkBlendOp";
    }
}

static inline const char* string_VkColorComponentFlagBits(VkColorComponentFlagBits input_value)
{
    switch (input_value)
    {
        case VK_COLOR_COMPONENT_A_BIT:
            return "VK_COLOR_COMPONENT_A_BIT";
        case VK_COLOR_COMPONENT_B_BIT:
            return "VK_COLOR_COMPONENT_B_BIT";
        case VK_COLOR_COMPONENT_G_BIT:
            return "VK_COLOR_COMPONENT_G_BIT";
        case VK_COLOR_COMPONENT_R_BIT:
            return "VK_COLOR_COMPONENT_R_BIT";
        default:
            return "Unhandled VkColorComponentFlagBits";
    }
}

static inline std::string string_VkColorComponentFlags(VkColorComponentFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkColorComponentFlagBits(static_cast<VkColorComponentFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkColorComponentFlagBits(static_cast<VkColorComponentFlagBits>(0)));
    return ret;
}

static inline const char* string_VkCompareOp(VkCompareOp input_value)
{
    switch (input_value)
    {
        case VK_COMPARE_OP_ALWAYS:
            return "VK_COMPARE_OP_ALWAYS";
        case VK_COMPARE_OP_EQUAL:
            return "VK_COMPARE_OP_EQUAL";
        case VK_COMPARE_OP_GREATER:
            return "VK_COMPARE_OP_GREATER";
        case VK_COMPARE_OP_GREATER_OR_EQUAL:
            return "VK_COMPARE_OP_GREATER_OR_EQUAL";
        case VK_COMPARE_OP_LESS:
            return "VK_COMPARE_OP_LESS";
        case VK_COMPARE_OP_LESS_OR_EQUAL:
            return "VK_COMPARE_OP_LESS_OR_EQUAL";
        case VK_COMPARE_OP_NEVER:
            return "VK_COMPARE_OP_NEVER";
        case VK_COMPARE_OP_NOT_EQUAL:
            return "VK_COMPARE_OP_NOT_EQUAL";
        default:
            return "Unhandled VkCompareOp";
    }
}

static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT:
            return "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT";
        case VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR:
            return "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
        case VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR:
            return "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR";
        case VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV:
            return "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV";
        case VK_PIPELINE_CREATE_DERIVATIVE_BIT:
            return "VK_PIPELINE_CREATE_DERIVATIVE_BIT";
        case VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
            return "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
        case VK_PIPELINE_CREATE_DISPATCH_BASE_BIT:
            return "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT";
        case VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT:
            return "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT";
        case VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT:
            return "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT";
        case VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV:
            return "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV";
        case VK_PIPELINE_CREATE_LIBRARY_BIT_KHR:
            return "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR";
        case VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT:
            return "VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT";
        case VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV:
            return "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV";
        case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR:
            return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
        case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR:
            return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR";
        case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR:
            return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR";
        case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR:
            return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR";
        case VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR:
            return "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR";
        case VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR:
            return "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR";
        case VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR:
            return "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR";
        case VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT:
            return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
        case VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
            return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        case VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT:
            return "VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT";
        case VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT:
            return "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT";
        default:
            return "Unhandled VkPipelineCreateFlagBits";
    }
}

static inline std::string string_VkPipelineCreateFlags(VkPipelineCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineCreateFlagBits(static_cast<VkPipelineCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT:
            return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT";
        case VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT:
            return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT";
        default:
            return "Unhandled VkPipelineShaderStageCreateFlagBits";
    }
}

static inline std::string string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SHADER_STAGE_ALL:
            return "VK_SHADER_STAGE_ALL";
        case VK_SHADER_STAGE_ALL_GRAPHICS:
            return "VK_SHADER_STAGE_ALL_GRAPHICS";
        case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
            return "VK_SHADER_STAGE_ANY_HIT_BIT_KHR";
        case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
            return "VK_SHADER_STAGE_CALLABLE_BIT_KHR";
        case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
            return "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR";
        case VK_SHADER_STAGE_COMPUTE_BIT:
            return "VK_SHADER_STAGE_COMPUTE_BIT";
        case VK_SHADER_STAGE_FRAGMENT_BIT:
            return "VK_SHADER_STAGE_FRAGMENT_BIT";
        case VK_SHADER_STAGE_GEOMETRY_BIT:
            return "VK_SHADER_STAGE_GEOMETRY_BIT";
        case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
            return "VK_SHADER_STAGE_INTERSECTION_BIT_KHR";
        case VK_SHADER_STAGE_MESH_BIT_NV:
            return "VK_SHADER_STAGE_MESH_BIT_NV";
        case VK_SHADER_STAGE_MISS_BIT_KHR:
            return "VK_SHADER_STAGE_MISS_BIT_KHR";
        case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
            return "VK_SHADER_STAGE_RAYGEN_BIT_KHR";
        case VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI:
            return "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI";
        case VK_SHADER_STAGE_TASK_BIT_NV:
            return "VK_SHADER_STAGE_TASK_BIT_NV";
        case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
            return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT";
        case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
            return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT";
        case VK_SHADER_STAGE_VERTEX_BIT:
            return "VK_SHADER_STAGE_VERTEX_BIT";
        default:
            return "Unhandled VkShaderStageFlagBits";
    }
}

static inline std::string string_VkShaderStageFlags(VkShaderStageFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkShaderStageFlagBits(static_cast<VkShaderStageFlagBits>(0)));
    return ret;
}

static inline const char* string_VkCullModeFlagBits(VkCullModeFlagBits input_value)
{
    switch (input_value)
    {
        case VK_CULL_MODE_BACK_BIT:
            return "VK_CULL_MODE_BACK_BIT";
        case VK_CULL_MODE_FRONT_AND_BACK:
            return "VK_CULL_MODE_FRONT_AND_BACK";
        case VK_CULL_MODE_FRONT_BIT:
            return "VK_CULL_MODE_FRONT_BIT";
        case VK_CULL_MODE_NONE:
            return "VK_CULL_MODE_NONE";
        default:
            return "Unhandled VkCullModeFlagBits";
    }
}

static inline std::string string_VkCullModeFlags(VkCullModeFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkCullModeFlagBits(static_cast<VkCullModeFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkCullModeFlagBits(static_cast<VkCullModeFlagBits>(0)));
    return ret;
}

static inline const char* string_VkDynamicState(VkDynamicState input_value)
{
    switch (input_value)
    {
        case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
            return "VK_DYNAMIC_STATE_BLEND_CONSTANTS";
        case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT:
            return "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT";
        case VK_DYNAMIC_STATE_CULL_MODE:
            return "VK_DYNAMIC_STATE_CULL_MODE";
        case VK_DYNAMIC_STATE_DEPTH_BIAS:
            return "VK_DYNAMIC_STATE_DEPTH_BIAS";
        case VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE:
            return "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE";
        case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
            return "VK_DYNAMIC_STATE_DEPTH_BOUNDS";
        case VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE:
            return "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE";
        case VK_DYNAMIC_STATE_DEPTH_COMPARE_OP:
            return "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP";
        case VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE:
            return "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE";
        case VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE:
            return "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE";
        case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
            return "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT";
        case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV:
            return "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV";
        case VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR:
            return "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR";
        case VK_DYNAMIC_STATE_FRONT_FACE:
            return "VK_DYNAMIC_STATE_FRONT_FACE";
        case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
            return "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT";
        case VK_DYNAMIC_STATE_LINE_WIDTH:
            return "VK_DYNAMIC_STATE_LINE_WIDTH";
        case VK_DYNAMIC_STATE_LOGIC_OP_EXT:
            return "VK_DYNAMIC_STATE_LOGIC_OP_EXT";
        case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT:
            return "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT";
        case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE:
            return "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE";
        case VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY:
            return "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY";
        case VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE:
            return "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE";
        case VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR:
            return "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR";
        case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
            return "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT";
        case VK_DYNAMIC_STATE_SCISSOR:
            return "VK_DYNAMIC_STATE_SCISSOR";
        case VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT:
            return "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT";
        case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
            return "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK";
        case VK_DYNAMIC_STATE_STENCIL_OP:
            return "VK_DYNAMIC_STATE_STENCIL_OP";
        case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
            return "VK_DYNAMIC_STATE_STENCIL_REFERENCE";
        case VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE:
            return "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE";
        case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
            return "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK";
        case VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE:
            return "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE";
        case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT:
            return "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT";
        case VK_DYNAMIC_STATE_VIEWPORT:
            return "VK_DYNAMIC_STATE_VIEWPORT";
        case VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV:
            return "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV";
        case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV:
            return "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV";
        case VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT:
            return "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT";
        case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
            return "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV";
        default:
            return "Unhandled VkDynamicState";
    }
}

static inline const char* string_VkFrontFace(VkFrontFace input_value)
{
    switch (input_value)
    {
        case VK_FRONT_FACE_CLOCKWISE:
            return "VK_FRONT_FACE_CLOCKWISE";
        case VK_FRONT_FACE_COUNTER_CLOCKWISE:
            return "VK_FRONT_FACE_COUNTER_CLOCKWISE";
        default:
            return "Unhandled VkFrontFace";
    }
}

static inline const char* string_VkVertexInputRate(VkVertexInputRate input_value)
{
    switch (input_value)
    {
        case VK_VERTEX_INPUT_RATE_INSTANCE:
            return "VK_VERTEX_INPUT_RATE_INSTANCE";
        case VK_VERTEX_INPUT_RATE_VERTEX:
            return "VK_VERTEX_INPUT_RATE_VERTEX";
        default:
            return "Unhandled VkVertexInputRate";
    }
}

static inline const char* string_VkPrimitiveTopology(VkPrimitiveTopology input_value)
{
    switch (input_value)
    {
        case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
            return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST";
        case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
            return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY";
        case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
            return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP";
        case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
            return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY";
        case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
            return "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST";
        case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
            return "VK_PRIMITIVE_TOPOLOGY_POINT_LIST";
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
            return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN";
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
            return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST";
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
            return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY";
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
            return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP";
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
            return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY";
        default:
            return "Unhandled VkPrimitiveTopology";
    }
}

static inline const char* string_VkPolygonMode(VkPolygonMode input_value)
{
    switch (input_value)
    {
        case VK_POLYGON_MODE_FILL:
            return "VK_POLYGON_MODE_FILL";
        case VK_POLYGON_MODE_FILL_RECTANGLE_NV:
            return "VK_POLYGON_MODE_FILL_RECTANGLE_NV";
        case VK_POLYGON_MODE_LINE:
            return "VK_POLYGON_MODE_LINE";
        case VK_POLYGON_MODE_POINT:
            return "VK_POLYGON_MODE_POINT";
        default:
            return "Unhandled VkPolygonMode";
    }
}

static inline const char* string_VkPipelineDepthStencilStateCreateFlagBits(VkPipelineDepthStencilStateCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM:
            return "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM";
        case VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM:
            return "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM";
        default:
            return "Unhandled VkPipelineDepthStencilStateCreateFlagBits";
    }
}

static inline std::string string_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineDepthStencilStateCreateFlagBits(static_cast<VkPipelineDepthStencilStateCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineDepthStencilStateCreateFlagBits(static_cast<VkPipelineDepthStencilStateCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkStencilOp(VkStencilOp input_value)
{
    switch (input_value)
    {
        case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
            return "VK_STENCIL_OP_DECREMENT_AND_CLAMP";
        case VK_STENCIL_OP_DECREMENT_AND_WRAP:
            return "VK_STENCIL_OP_DECREMENT_AND_WRAP";
        case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
            return "VK_STENCIL_OP_INCREMENT_AND_CLAMP";
        case VK_STENCIL_OP_INCREMENT_AND_WRAP:
            return "VK_STENCIL_OP_INCREMENT_AND_WRAP";
        case VK_STENCIL_OP_INVERT:
            return "VK_STENCIL_OP_INVERT";
        case VK_STENCIL_OP_KEEP:
            return "VK_STENCIL_OP_KEEP";
        case VK_STENCIL_OP_REPLACE:
            return "VK_STENCIL_OP_REPLACE";
        case VK_STENCIL_OP_ZERO:
            return "VK_STENCIL_OP_ZERO";
        default:
            return "Unhandled VkStencilOp";
    }
}

static inline const char* string_VkPipelineColorBlendStateCreateFlagBits(VkPipelineColorBlendStateCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM:
            return "VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM";
        default:
            return "Unhandled VkPipelineColorBlendStateCreateFlagBits";
    }
}

static inline std::string string_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineColorBlendStateCreateFlagBits(static_cast<VkPipelineColorBlendStateCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineColorBlendStateCreateFlagBits(static_cast<VkPipelineColorBlendStateCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkLogicOp(VkLogicOp input_value)
{
    switch (input_value)
    {
        case VK_LOGIC_OP_AND:
            return "VK_LOGIC_OP_AND";
        case VK_LOGIC_OP_AND_INVERTED:
            return "VK_LOGIC_OP_AND_INVERTED";
        case VK_LOGIC_OP_AND_REVERSE:
            return "VK_LOGIC_OP_AND_REVERSE";
        case VK_LOGIC_OP_CLEAR:
            return "VK_LOGIC_OP_CLEAR";
        case VK_LOGIC_OP_COPY:
            return "VK_LOGIC_OP_COPY";
        case VK_LOGIC_OP_COPY_INVERTED:
            return "VK_LOGIC_OP_COPY_INVERTED";
        case VK_LOGIC_OP_EQUIVALENT:
            return "VK_LOGIC_OP_EQUIVALENT";
        case VK_LOGIC_OP_INVERT:
            return "VK_LOGIC_OP_INVERT";
        case VK_LOGIC_OP_NAND:
            return "VK_LOGIC_OP_NAND";
        case VK_LOGIC_OP_NOR:
            return "VK_LOGIC_OP_NOR";
        case VK_LOGIC_OP_NO_OP:
            return "VK_LOGIC_OP_NO_OP";
        case VK_LOGIC_OP_OR:
            return "VK_LOGIC_OP_OR";
        case VK_LOGIC_OP_OR_INVERTED:
            return "VK_LOGIC_OP_OR_INVERTED";
        case VK_LOGIC_OP_OR_REVERSE:
            return "VK_LOGIC_OP_OR_REVERSE";
        case VK_LOGIC_OP_SET:
            return "VK_LOGIC_OP_SET";
        case VK_LOGIC_OP_XOR:
            return "VK_LOGIC_OP_XOR";
        default:
            return "Unhandled VkLogicOp";
    }
}

static inline const char* string_VkPipelineLayoutCreateFlagBits(VkPipelineLayoutCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT:
            return "VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT";
        default:
            return "Unhandled VkPipelineLayoutCreateFlagBits";
    }
}

static inline std::string string_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineLayoutCreateFlagBits(static_cast<VkPipelineLayoutCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineLayoutCreateFlagBits(static_cast<VkPipelineLayoutCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkBorderColor(VkBorderColor input_value)
{
    switch (input_value)
    {
        case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
            return "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT";
        case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
            return "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK";
        case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
            return "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE";
        case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
            return "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK";
        case VK_BORDER_COLOR_INT_CUSTOM_EXT:
            return "VK_BORDER_COLOR_INT_CUSTOM_EXT";
        case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
            return "VK_BORDER_COLOR_INT_OPAQUE_BLACK";
        case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
            return "VK_BORDER_COLOR_INT_OPAQUE_WHITE";
        case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
            return "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK";
        default:
            return "Unhandled VkBorderColor";
    }
}

static inline const char* string_VkFilter(VkFilter input_value)
{
    switch (input_value)
    {
        case VK_FILTER_CUBIC_IMG:
            return "VK_FILTER_CUBIC_IMG";
        case VK_FILTER_LINEAR:
            return "VK_FILTER_LINEAR";
        case VK_FILTER_NEAREST:
            return "VK_FILTER_NEAREST";
        default:
            return "Unhandled VkFilter";
    }
}

static inline const char* string_VkSamplerAddressMode(VkSamplerAddressMode input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
            return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER";
        case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
            return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE";
        case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
            return "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT";
        case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
            return "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE";
        case VK_SAMPLER_ADDRESS_MODE_REPEAT:
            return "VK_SAMPLER_ADDRESS_MODE_REPEAT";
        default:
            return "Unhandled VkSamplerAddressMode";
    }
}

static inline const char* string_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT:
            return "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT";
        case VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT:
            return "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT";
        default:
            return "Unhandled VkSamplerCreateFlagBits";
    }
}

static inline std::string string_VkSamplerCreateFlags(VkSamplerCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSamplerCreateFlagBits(static_cast<VkSamplerCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSamplerCreateFlagBits(static_cast<VkSamplerCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSamplerMipmapMode(VkSamplerMipmapMode input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_MIPMAP_MODE_LINEAR:
            return "VK_SAMPLER_MIPMAP_MODE_LINEAR";
        case VK_SAMPLER_MIPMAP_MODE_NEAREST:
            return "VK_SAMPLER_MIPMAP_MODE_NEAREST";
        default:
            return "Unhandled VkSamplerMipmapMode";
    }
}

static inline const char* string_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT:
            return "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT";
        case VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE:
            return "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE";
        case VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT:
            return "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT";
        default:
            return "Unhandled VkDescriptorPoolCreateFlagBits";
    }
}

static inline std::string string_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDescriptorPoolCreateFlagBits(static_cast<VkDescriptorPoolCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDescriptorPoolCreateFlagBits(static_cast<VkDescriptorPoolCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkDescriptorType(VkDescriptorType input_value)
{
    switch (input_value)
    {
        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
            return "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR";
        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
            return "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV";
        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
            return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER";
        case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
            return "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK";
        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
            return "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT";
        case VK_DESCRIPTOR_TYPE_MUTABLE_VALVE:
            return "VK_DESCRIPTOR_TYPE_MUTABLE_VALVE";
        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
            return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE";
        case VK_DESCRIPTOR_TYPE_SAMPLER:
            return "VK_DESCRIPTOR_TYPE_SAMPLER";
        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
            return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER";
        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
            return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC";
        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
            return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE";
        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
            return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER";
        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
            return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
            return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
            return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER";
        default:
            return "Unhandled VkDescriptorType";
    }
}

static inline const char* string_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE:
            return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE";
        case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR:
            return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR";
        case VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT:
            return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT";
        default:
            return "Unhandled VkDescriptorSetLayoutCreateFlagBits";
    }
}

static inline std::string string_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDescriptorSetLayoutCreateFlagBits(static_cast<VkDescriptorSetLayoutCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDescriptorSetLayoutCreateFlagBits(static_cast<VkDescriptorSetLayoutCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits input_value)
{
    switch (input_value)
    {
        case VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT:
            return "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT";
        default:
            return "Unhandled VkAttachmentDescriptionFlagBits";
    }
}

static inline std::string string_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkAttachmentDescriptionFlagBits(static_cast<VkAttachmentDescriptionFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkAttachmentDescriptionFlagBits(static_cast<VkAttachmentDescriptionFlagBits>(0)));
    return ret;
}

static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_value)
{
    switch (input_value)
    {
        case VK_ATTACHMENT_LOAD_OP_CLEAR:
            return "VK_ATTACHMENT_LOAD_OP_CLEAR";
        case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
            return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
        case VK_ATTACHMENT_LOAD_OP_LOAD:
            return "VK_ATTACHMENT_LOAD_OP_LOAD";
        case VK_ATTACHMENT_LOAD_OP_NONE_EXT:
            return "VK_ATTACHMENT_LOAD_OP_NONE_EXT";
        default:
            return "Unhandled VkAttachmentLoadOp";
    }
}

static inline const char* string_VkAttachmentStoreOp(VkAttachmentStoreOp input_value)
{
    switch (input_value)
    {
        case VK_ATTACHMENT_STORE_OP_DONT_CARE:
            return "VK_ATTACHMENT_STORE_OP_DONT_CARE";
        case VK_ATTACHMENT_STORE_OP_NONE:
            return "VK_ATTACHMENT_STORE_OP_NONE";
        case VK_ATTACHMENT_STORE_OP_STORE:
            return "VK_ATTACHMENT_STORE_OP_STORE";
        default:
            return "Unhandled VkAttachmentStoreOp";
    }
}

static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input_value)
{
    switch (input_value)
    {
        case VK_DEPENDENCY_BY_REGION_BIT:
            return "VK_DEPENDENCY_BY_REGION_BIT";
        case VK_DEPENDENCY_DEVICE_GROUP_BIT:
            return "VK_DEPENDENCY_DEVICE_GROUP_BIT";
        case VK_DEPENDENCY_VIEW_LOCAL_BIT:
            return "VK_DEPENDENCY_VIEW_LOCAL_BIT";
        default:
            return "Unhandled VkDependencyFlagBits";
    }
}

static inline std::string string_VkDependencyFlags(VkDependencyFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDependencyFlagBits(static_cast<VkDependencyFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDependencyFlagBits(static_cast<VkDependencyFlagBits>(0)));
    return ret;
}

static inline const char* string_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT:
            return "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT";
        default:
            return "Unhandled VkFramebufferCreateFlagBits";
    }
}

static inline std::string string_VkFramebufferCreateFlags(VkFramebufferCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkFramebufferCreateFlagBits(static_cast<VkFramebufferCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkFramebufferCreateFlagBits(static_cast<VkFramebufferCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPipelineBindPoint(VkPipelineBindPoint input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_BIND_POINT_COMPUTE:
            return "VK_PIPELINE_BIND_POINT_COMPUTE";
        case VK_PIPELINE_BIND_POINT_GRAPHICS:
            return "VK_PIPELINE_BIND_POINT_GRAPHICS";
        case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR:
            return "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR";
        case VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI:
            return "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI";
        default:
            return "Unhandled VkPipelineBindPoint";
    }
}

static inline const char* string_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM:
            return "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM";
        default:
            return "Unhandled VkRenderPassCreateFlagBits";
    }
}

static inline std::string string_VkRenderPassCreateFlags(VkRenderPassCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkRenderPassCreateFlagBits(static_cast<VkRenderPassCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkRenderPassCreateFlagBits(static_cast<VkRenderPassCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM:
            return "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM";
        case VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX:
            return "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX";
        case VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX:
            return "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX";
        case VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM:
            return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM";
        case VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM:
            return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM";
        case VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM:
            return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM";
        case VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM:
            return "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM";
        default:
            return "Unhandled VkSubpassDescriptionFlagBits";
    }
}

static inline std::string string_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSubpassDescriptionFlagBits(static_cast<VkSubpassDescriptionFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSubpassDescriptionFlagBits(static_cast<VkSubpassDescriptionFlagBits>(0)));
    return ret;
}

static inline const char* string_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_COMMAND_POOL_CREATE_PROTECTED_BIT:
            return "VK_COMMAND_POOL_CREATE_PROTECTED_BIT";
        case VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT:
            return "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT";
        case VK_COMMAND_POOL_CREATE_TRANSIENT_BIT:
            return "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT";
        default:
            return "Unhandled VkCommandPoolCreateFlagBits";
    }
}

static inline std::string string_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkCommandPoolCreateFlagBits(static_cast<VkCommandPoolCreateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkCommandPoolCreateFlagBits(static_cast<VkCommandPoolCreateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits input_value)
{
    switch (input_value)
    {
        case VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT:
            return "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT";
        default:
            return "Unhandled VkCommandPoolResetFlagBits";
    }
}

static inline std::string string_VkCommandPoolResetFlags(VkCommandPoolResetFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkCommandPoolResetFlagBits(static_cast<VkCommandPoolResetFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkCommandPoolResetFlagBits(static_cast<VkCommandPoolResetFlagBits>(0)));
    return ret;
}

static inline const char* string_VkCommandBufferLevel(VkCommandBufferLevel input_value)
{
    switch (input_value)
    {
        case VK_COMMAND_BUFFER_LEVEL_PRIMARY:
            return "VK_COMMAND_BUFFER_LEVEL_PRIMARY";
        case VK_COMMAND_BUFFER_LEVEL_SECONDARY:
            return "VK_COMMAND_BUFFER_LEVEL_SECONDARY";
        default:
            return "Unhandled VkCommandBufferLevel";
    }
}

static inline const char* string_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits input_value)
{
    switch (input_value)
    {
        case VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT:
            return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT";
        case VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT:
            return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT";
        case VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT:
            return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT";
        default:
            return "Unhandled VkCommandBufferUsageFlagBits";
    }
}

static inline std::string string_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkCommandBufferUsageFlagBits(static_cast<VkCommandBufferUsageFlagBits>(0)));
    return ret;
}

static inline const char* string_VkQueryControlFlagBits(VkQueryControlFlagBits input_value)
{
    switch (input_value)
    {
        case VK_QUERY_CONTROL_PRECISE_BIT:
            return "VK_QUERY_CONTROL_PRECISE_BIT";
        default:
            return "Unhandled VkQueryControlFlagBits";
    }
}

static inline std::string string_VkQueryControlFlags(VkQueryControlFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkQueryControlFlagBits(static_cast<VkQueryControlFlagBits>(0)));
    return ret;
}

static inline const char* string_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits input_value)
{
    switch (input_value)
    {
        case VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT:
            return "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT";
        default:
            return "Unhandled VkCommandBufferResetFlagBits";
    }
}

static inline std::string string_VkCommandBufferResetFlags(VkCommandBufferResetFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkCommandBufferResetFlagBits(static_cast<VkCommandBufferResetFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkCommandBufferResetFlagBits(static_cast<VkCommandBufferResetFlagBits>(0)));
    return ret;
}

static inline const char* string_VkIndexType(VkIndexType input_value)
{
    switch (input_value)
    {
        case VK_INDEX_TYPE_NONE_KHR:
            return "VK_INDEX_TYPE_NONE_KHR";
        case VK_INDEX_TYPE_UINT16:
            return "VK_INDEX_TYPE_UINT16";
        case VK_INDEX_TYPE_UINT32:
            return "VK_INDEX_TYPE_UINT32";
        case VK_INDEX_TYPE_UINT8_EXT:
            return "VK_INDEX_TYPE_UINT8_EXT";
        default:
            return "Unhandled VkIndexType";
    }
}

static inline const char* string_VkStencilFaceFlagBits(VkStencilFaceFlagBits input_value)
{
    switch (input_value)
    {
        case VK_STENCIL_FACE_BACK_BIT:
            return "VK_STENCIL_FACE_BACK_BIT";
        case VK_STENCIL_FACE_FRONT_AND_BACK:
            return "VK_STENCIL_FACE_FRONT_AND_BACK";
        case VK_STENCIL_FACE_FRONT_BIT:
            return "VK_STENCIL_FACE_FRONT_BIT";
        default:
            return "Unhandled VkStencilFaceFlagBits";
    }
}

static inline std::string string_VkStencilFaceFlags(VkStencilFaceFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkStencilFaceFlagBits(static_cast<VkStencilFaceFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkStencilFaceFlagBits(static_cast<VkStencilFaceFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSubpassContents(VkSubpassContents input_value)
{
    switch (input_value)
    {
        case VK_SUBPASS_CONTENTS_INLINE:
            return "VK_SUBPASS_CONTENTS_INLINE";
        case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS:
            return "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS";
        default:
            return "Unhandled VkSubpassContents";
    }
}

static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SUBGROUP_FEATURE_ARITHMETIC_BIT:
            return "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT";
        case VK_SUBGROUP_FEATURE_BALLOT_BIT:
            return "VK_SUBGROUP_FEATURE_BALLOT_BIT";
        case VK_SUBGROUP_FEATURE_BASIC_BIT:
            return "VK_SUBGROUP_FEATURE_BASIC_BIT";
        case VK_SUBGROUP_FEATURE_CLUSTERED_BIT:
            return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT";
        case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV:
            return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV";
        case VK_SUBGROUP_FEATURE_QUAD_BIT:
            return "VK_SUBGROUP_FEATURE_QUAD_BIT";
        case VK_SUBGROUP_FEATURE_SHUFFLE_BIT:
            return "VK_SUBGROUP_FEATURE_SHUFFLE_BIT";
        case VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT:
            return "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT";
        case VK_SUBGROUP_FEATURE_VOTE_BIT:
            return "VK_SUBGROUP_FEATURE_VOTE_BIT";
        default:
            return "Unhandled VkSubgroupFeatureFlagBits";
    }
}

static inline std::string string_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSubgroupFeatureFlagBits(static_cast<VkSubgroupFeatureFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PEER_MEMORY_FEATURE_COPY_DST_BIT:
            return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT";
        case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT:
            return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT";
        case VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT:
            return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT";
        case VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT:
            return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT";
        default:
            return "Unhandled VkPeerMemoryFeatureFlagBits";
    }
}

static inline std::string string_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPeerMemoryFeatureFlagBits(static_cast<VkPeerMemoryFeatureFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPeerMemoryFeatureFlagBits(static_cast<VkPeerMemoryFeatureFlagBits>(0)));
    return ret;
}

static inline const char* string_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits input_value)
{
    switch (input_value)
    {
        case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT:
            return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT";
        case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT:
            return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
        case VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT:
            return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT";
        default:
            return "Unhandled VkMemoryAllocateFlagBits";
    }
}

static inline std::string string_VkMemoryAllocateFlags(VkMemoryAllocateFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkMemoryAllocateFlagBits(static_cast<VkMemoryAllocateFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkMemoryAllocateFlagBits(static_cast<VkMemoryAllocateFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPointClippingBehavior(VkPointClippingBehavior input_value)
{
    switch (input_value)
    {
        case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
            return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
        case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
            return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
        default:
            return "Unhandled VkPointClippingBehavior";
    }
}

static inline const char* string_VkTessellationDomainOrigin(VkTessellationDomainOrigin input_value)
{
    switch (input_value)
    {
        case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT:
            return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT";
        case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
            return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT";
        default:
            return "Unhandled VkTessellationDomainOrigin";
    }
}

static inline const char* string_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY";
        default:
            return "Unhandled VkSamplerYcbcrModelConversion";
    }
}

static inline const char* string_VkSamplerYcbcrRange(VkSamplerYcbcrRange input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
            return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL";
        case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
            return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW";
        default:
            return "Unhandled VkSamplerYcbcrRange";
    }
}

static inline const char* string_VkChromaLocation(VkChromaLocation input_value)
{
    switch (input_value)
    {
        case VK_CHROMA_LOCATION_COSITED_EVEN:
            return "VK_CHROMA_LOCATION_COSITED_EVEN";
        case VK_CHROMA_LOCATION_MIDPOINT:
            return "VK_CHROMA_LOCATION_MIDPOINT";
        default:
            return "Unhandled VkChromaLocation";
    }
}

static inline const char* string_VkDescriptorUpdateTemplateType(VkDescriptorUpdateTemplateType input_value)
{
    switch (input_value)
    {
        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
            return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
            return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
        default:
            return "Unhandled VkDescriptorUpdateTemplateType";
    }
}

static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA";
        default:
            return "Unhandled VkExternalMemoryHandleTypeFlagBits";
    }
}

static inline std::string string_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalMemoryHandleTypeFlagBits(static_cast<VkExternalMemoryHandleTypeFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBits(static_cast<VkExternalMemoryHandleTypeFlagBits>(0)));
    return ret;
}

static inline const char* string_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT:
            return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT";
        case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT:
            return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT";
        case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT:
            return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT";
        default:
            return "Unhandled VkExternalMemoryFeatureFlagBits";
    }
}

static inline std::string string_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalMemoryFeatureFlagBits(static_cast<VkExternalMemoryFeatureFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBits(static_cast<VkExternalMemoryFeatureFlagBits>(0)));
    return ret;
}

static inline const char* string_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT";
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT";
        default:
            return "Unhandled VkExternalFenceHandleTypeFlagBits";
    }
}

static inline std::string string_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalFenceHandleTypeFlagBits(static_cast<VkExternalFenceHandleTypeFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalFenceHandleTypeFlagBits(static_cast<VkExternalFenceHandleTypeFlagBits>(0)));
    return ret;
}

static inline const char* string_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT:
            return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT";
        case VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT:
            return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT";
        default:
            return "Unhandled VkExternalFenceFeatureFlagBits";
    }
}

static inline std::string string_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalFenceFeatureFlagBits(static_cast<VkExternalFenceFeatureFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalFenceFeatureFlagBits(static_cast<VkExternalFenceFeatureFlagBits>(0)));
    return ret;
}

static inline const char* string_VkFenceImportFlagBits(VkFenceImportFlagBits input_value)
{
    switch (input_value)
    {
        case VK_FENCE_IMPORT_TEMPORARY_BIT:
            return "VK_FENCE_IMPORT_TEMPORARY_BIT";
        default:
            return "Unhandled VkFenceImportFlagBits";
    }
}

static inline std::string string_VkFenceImportFlags(VkFenceImportFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkFenceImportFlagBits(static_cast<VkFenceImportFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkFenceImportFlagBits(static_cast<VkFenceImportFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SEMAPHORE_IMPORT_TEMPORARY_BIT:
            return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
        default:
            return "Unhandled VkSemaphoreImportFlagBits";
    }
}

static inline std::string string_VkSemaphoreImportFlags(VkSemaphoreImportFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSemaphoreImportFlagBits(static_cast<VkSemaphoreImportFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSemaphoreImportFlagBits(static_cast<VkSemaphoreImportFlagBits>(0)));
    return ret;
}

static inline const char* string_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA";
        default:
            return "Unhandled VkExternalSemaphoreHandleTypeFlagBits";
    }
}

static inline std::string string_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalSemaphoreHandleTypeFlagBits(static_cast<VkExternalSemaphoreHandleTypeFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalSemaphoreHandleTypeFlagBits(static_cast<VkExternalSemaphoreHandleTypeFlagBits>(0)));
    return ret;
}

static inline const char* string_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT:
            return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT";
        case VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT:
            return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT";
        default:
            return "Unhandled VkExternalSemaphoreFeatureFlagBits";
    }
}

static inline std::string string_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalSemaphoreFeatureFlagBits(static_cast<VkExternalSemaphoreFeatureFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalSemaphoreFeatureFlagBits(static_cast<VkExternalSemaphoreFeatureFlagBits>(0)));
    return ret;
}

static inline const char* string_VkDriverId(VkDriverId input_value)
{
    switch (input_value)
    {
        case VK_DRIVER_ID_AMD_OPEN_SOURCE:
            return "VK_DRIVER_ID_AMD_OPEN_SOURCE";
        case VK_DRIVER_ID_AMD_PROPRIETARY:
            return "VK_DRIVER_ID_AMD_PROPRIETARY";
        case VK_DRIVER_ID_ARM_PROPRIETARY:
            return "VK_DRIVER_ID_ARM_PROPRIETARY";
        case VK_DRIVER_ID_BROADCOM_PROPRIETARY:
            return "VK_DRIVER_ID_BROADCOM_PROPRIETARY";
        case VK_DRIVER_ID_COREAVI_PROPRIETARY:
            return "VK_DRIVER_ID_COREAVI_PROPRIETARY";
        case VK_DRIVER_ID_GGP_PROPRIETARY:
            return "VK_DRIVER_ID_GGP_PROPRIETARY";
        case VK_DRIVER_ID_GOOGLE_SWIFTSHADER:
            return "VK_DRIVER_ID_GOOGLE_SWIFTSHADER";
        case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
            return "VK_DRIVER_ID_IMAGINATION_PROPRIETARY";
        case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
            return "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
        case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
            return "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
        case VK_DRIVER_ID_JUICE_PROPRIETARY:
            return "VK_DRIVER_ID_JUICE_PROPRIETARY";
        case VK_DRIVER_ID_MESA_LLVMPIPE:
            return "VK_DRIVER_ID_MESA_LLVMPIPE";
        case VK_DRIVER_ID_MESA_PANVK:
            return "VK_DRIVER_ID_MESA_PANVK";
        case VK_DRIVER_ID_MESA_RADV:
            return "VK_DRIVER_ID_MESA_RADV";
        case VK_DRIVER_ID_MESA_TURNIP:
            return "VK_DRIVER_ID_MESA_TURNIP";
        case VK_DRIVER_ID_MESA_V3DV:
            return "VK_DRIVER_ID_MESA_V3DV";
        case VK_DRIVER_ID_MESA_VENUS:
            return "VK_DRIVER_ID_MESA_VENUS";
        case VK_DRIVER_ID_MOLTENVK:
            return "VK_DRIVER_ID_MOLTENVK";
        case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
            return "VK_DRIVER_ID_NVIDIA_PROPRIETARY";
        case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
            return "VK_DRIVER_ID_QUALCOMM_PROPRIETARY";
        case VK_DRIVER_ID_SAMSUNG_PROPRIETARY:
            return "VK_DRIVER_ID_SAMSUNG_PROPRIETARY";
        case VK_DRIVER_ID_VERISILICON_PROPRIETARY:
            return "VK_DRIVER_ID_VERISILICON_PROPRIETARY";
        default:
            return "Unhandled VkDriverId";
    }
}

static inline const char* string_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence input_value)
{
    switch (input_value)
    {
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY:
            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL:
            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE:
            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
        default:
            return "Unhandled VkShaderFloatControlsIndependence";
    }
}

static inline const char* string_VkResolveModeFlagBits(VkResolveModeFlagBits input_value)
{
    switch (input_value)
    {
        case VK_RESOLVE_MODE_AVERAGE_BIT:
            return "VK_RESOLVE_MODE_AVERAGE_BIT";
        case VK_RESOLVE_MODE_MAX_BIT:
            return "VK_RESOLVE_MODE_MAX_BIT";
        case VK_RESOLVE_MODE_MIN_BIT:
            return "VK_RESOLVE_MODE_MIN_BIT";
        case VK_RESOLVE_MODE_NONE:
            return "VK_RESOLVE_MODE_NONE";
        case VK_RESOLVE_MODE_SAMPLE_ZERO_BIT:
            return "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT";
        default:
            return "Unhandled VkResolveModeFlagBits";
    }
}

static inline std::string string_VkResolveModeFlags(VkResolveModeFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkResolveModeFlagBits(static_cast<VkResolveModeFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkResolveModeFlagBits(static_cast<VkResolveModeFlagBits>(0)));
    return ret;
}

static inline const char* string_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits input_value)
{
    switch (input_value)
    {
        case VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT:
            return "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT";
        case VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT:
            return "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT";
        case VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT:
            return "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT";
        case VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT:
            return "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT";
        default:
            return "Unhandled VkDescriptorBindingFlagBits";
    }
}

static inline std::string string_VkDescriptorBindingFlags(VkDescriptorBindingFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDescriptorBindingFlagBits(static_cast<VkDescriptorBindingFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDescriptorBindingFlagBits(static_cast<VkDescriptorBindingFlagBits>(0)));
    return ret;
}

static inline const char* string_VkSamplerReductionMode(VkSamplerReductionMode input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_REDUCTION_MODE_MAX:
            return "VK_SAMPLER_REDUCTION_MODE_MAX";
        case VK_SAMPLER_REDUCTION_MODE_MIN:
            return "VK_SAMPLER_REDUCTION_MODE_MIN";
        case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE:
            return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE";
        default:
            return "Unhandled VkSamplerReductionMode";
    }
}

static inline const char* string_VkSemaphoreType(VkSemaphoreType input_value)
{
    switch (input_value)
    {
        case VK_SEMAPHORE_TYPE_BINARY:
            return "VK_SEMAPHORE_TYPE_BINARY";
        case VK_SEMAPHORE_TYPE_TIMELINE:
            return "VK_SEMAPHORE_TYPE_TIMELINE";
        default:
            return "Unhandled VkSemaphoreType";
    }
}

static inline const char* string_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SEMAPHORE_WAIT_ANY_BIT:
            return "VK_SEMAPHORE_WAIT_ANY_BIT";
        default:
            return "Unhandled VkSemaphoreWaitFlagBits";
    }
}

static inline std::string string_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSemaphoreWaitFlagBits(static_cast<VkSemaphoreWaitFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSemaphoreWaitFlagBits(static_cast<VkSemaphoreWaitFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPipelineCreationFeedbackFlagBits(VkPipelineCreationFeedbackFlagBits input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT:
            return "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT";
        case VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT:
            return "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT";
        case VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT:
            return "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT";
        default:
            return "Unhandled VkPipelineCreationFeedbackFlagBits";
    }
}

static inline std::string string_VkPipelineCreationFeedbackFlags(VkPipelineCreationFeedbackFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineCreationFeedbackFlagBits(static_cast<VkPipelineCreationFeedbackFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineCreationFeedbackFlagBits(static_cast<VkPipelineCreationFeedbackFlagBits>(0)));
    return ret;
}

static inline const char* string_VkToolPurposeFlagBits(VkToolPurposeFlagBits input_value)
{
    switch (input_value)
    {
        case VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT:
            return "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT";
        case VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT:
            return "VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT";
        case VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT:
            return "VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT";
        case VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT:
            return "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT";
        case VK_TOOL_PURPOSE_PROFILING_BIT:
            return "VK_TOOL_PURPOSE_PROFILING_BIT";
        case VK_TOOL_PURPOSE_TRACING_BIT:
            return "VK_TOOL_PURPOSE_TRACING_BIT";
        case VK_TOOL_PURPOSE_VALIDATION_BIT:
            return "VK_TOOL_PURPOSE_VALIDATION_BIT";
        default:
            return "Unhandled VkToolPurposeFlagBits";
    }
}

static inline std::string string_VkToolPurposeFlags(VkToolPurposeFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkToolPurposeFlagBits(static_cast<VkToolPurposeFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkToolPurposeFlagBits(static_cast<VkToolPurposeFlagBits>(0)));
    return ret;
}

static inline const char* string_VkPipelineStageFlagBits2(uint64_t input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
        case VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR";
        case VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT:
            return "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT";
        case VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT:
            return "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT";
        case VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT:
            return "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT";
        case VK_PIPELINE_STAGE_2_BLIT_BIT:
            return "VK_PIPELINE_STAGE_2_BLIT_BIT";
        case VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT:
            return "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT";
        case VK_PIPELINE_STAGE_2_CLEAR_BIT:
            return "VK_PIPELINE_STAGE_2_CLEAR_BIT";
        case VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT:
            return "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT";
        case VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV:
            return "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV";
        case VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT:
            return "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
        case VK_PIPELINE_STAGE_2_COPY_BIT:
            return "VK_PIPELINE_STAGE_2_COPY_BIT";
        case VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT:
            return "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT";
        case VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT:
            return "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT";
        case VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
            return "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
        case VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        case VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_HOST_BIT:
            return "VK_PIPELINE_STAGE_2_HOST_BIT";
        case VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT:
            return "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT";
        case VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI:
            return "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI";
        case VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT:
            return "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT";
        case VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV:
            return "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV";
        case VK_PIPELINE_STAGE_2_NONE:
            return "VK_PIPELINE_STAGE_2_NONE";
        case VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT:
            return "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT";
        case VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR";
        case VK_PIPELINE_STAGE_2_RESOLVE_BIT:
            return "VK_PIPELINE_STAGE_2_RESOLVE_BIT";
        case VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI:
            return "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI";
        case VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV:
            return "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV";
        case VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT:
            return "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT";
        case VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT:
            return "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT";
        case VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT:
            return "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT";
        case VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT:
            return "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT";
        case VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkPipelineStageFlagBits2";
    }
}

static inline std::string string_VkPipelineStageFlags2(VkPipelineStageFlags2 input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineStageFlagBits2(static_cast<uint64_t>(1ULL << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineStageFlagBits2(static_cast<uint64_t>(0)));
    return ret;
}

static inline const char* string_VkAccessFlagBits2(uint64_t input_value)
{
    switch (input_value)
    {
        case VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR:
            return "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR";
        case VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR:
            return "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
        case VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT";
        case VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
            return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
        case VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT:
            return "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT";
        case VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV:
            return "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV";
        case VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV:
            return "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV";
        case VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT:
            return "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT";
        case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
        case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
            return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
        case VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
            return "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
        case VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
            return "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
        case VK_ACCESS_2_HOST_READ_BIT:
            return "VK_ACCESS_2_HOST_READ_BIT";
        case VK_ACCESS_2_HOST_WRITE_BIT:
            return "VK_ACCESS_2_HOST_WRITE_BIT";
        case VK_ACCESS_2_INDEX_READ_BIT:
            return "VK_ACCESS_2_INDEX_READ_BIT";
        case VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT:
            return "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT";
        case VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT";
        case VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI:
            return "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI";
        case VK_ACCESS_2_MEMORY_READ_BIT:
            return "VK_ACCESS_2_MEMORY_READ_BIT";
        case VK_ACCESS_2_MEMORY_WRITE_BIT:
            return "VK_ACCESS_2_MEMORY_WRITE_BIT";
        case VK_ACCESS_2_NONE:
            return "VK_ACCESS_2_NONE";
        case VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR:
            return "VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR";
        case VK_ACCESS_2_SHADER_READ_BIT:
            return "VK_ACCESS_2_SHADER_READ_BIT";
        case VK_ACCESS_2_SHADER_SAMPLED_READ_BIT:
            return "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT";
        case VK_ACCESS_2_SHADER_STORAGE_READ_BIT:
            return "VK_ACCESS_2_SHADER_STORAGE_READ_BIT";
        case VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT:
            return "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT";
        case VK_ACCESS_2_SHADER_WRITE_BIT:
            return "VK_ACCESS_2_SHADER_WRITE_BIT";
        case VK_ACCESS_2_TRANSFER_READ_BIT:
            return "VK_ACCESS_2_TRANSFER_READ_BIT";
        case VK_ACCESS_2_TRANSFER_WRITE_BIT:
            return "VK_ACCESS_2_TRANSFER_WRITE_BIT";
        case VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
            return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
        case VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
            return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
        case VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
            return "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
        case VK_ACCESS_2_UNIFORM_READ_BIT:
            return "VK_ACCESS_2_UNIFORM_READ_BIT";
        case VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT:
            return "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkAccessFlagBits2";
    }
}

static inline std::string string_VkAccessFlags2(VkAccessFlags2 input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkAccessFlagBits2(static_cast<uint64_t>(1ULL << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkAccessFlagBits2(static_cast<uint64_t>(0)));
    return ret;
}

static inline const char* string_VkSubmitFlagBits(VkSubmitFlagBits input_value)
{
    switch (input_value)
    {
        case VK_SUBMIT_PROTECTED_BIT:
            return "VK_SUBMIT_PROTECTED_BIT";
        default:
            return "Unhandled VkSubmitFlagBits";
    }
}

static inline std::string string_VkSubmitFlags(VkSubmitFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSubmitFlagBits(static_cast<VkSubmitFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSubmitFlagBits(static_cast<VkSubmitFlagBits>(0)));
    return ret;
}

static inline const char* string_VkRenderingFlagBits(VkRenderingFlagBits input_value)
{
    switch (input_value)
    {
        case VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT:
            return "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT";
        case VK_RENDERING_RESUMING_BIT:
            return "VK_RENDERING_RESUMING_BIT";
        case VK_RENDERING_SUSPENDING_BIT:
            return "VK_RENDERING_SUSPENDING_BIT";
        default:
            return "Unhandled VkRenderingFlagBits";
    }
}

static inline std::string string_VkRenderingFlags(VkRenderingFlags input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkRenderingFlagBits(static_cast<VkRenderingFlagBits>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkRenderingFlagBits(static_cast<VkRenderingFlagBits>(0)));
    return ret;
}

static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
{
    switch (input_value)
    {
        case VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR";
        case VK_FORMAT_FEATURE_2_BLIT_DST_BIT:
            return "VK_FORMAT_FEATURE_2_BLIT_DST_BIT";
        case VK_FORMAT_FEATURE_2_BLIT_SRC_BIT:
            return "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT";
        case VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT:
            return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT";
        case VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT:
            return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT";
        case VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT:
            return "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT";
        case VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT:
            return "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT";
        case VK_FORMAT_FEATURE_2_DISJOINT_BIT:
            return "VK_FORMAT_FEATURE_2_DISJOINT_BIT";
        case VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT:
            return "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT";
        case VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        case VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV:
            return "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV";
        case VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT:
            return "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT";
        case VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT:
            return "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT";
        case VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT:
            return "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT";
        case VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT:
            return "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT";
        case VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT:
            return "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkFormatFeatureFlagBits2";
    }
}

static inline std::string string_VkFormatFeatureFlags2(VkFormatFeatureFlags2 input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkFormatFeatureFlagBits2(static_cast<uint64_t>(1ULL << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkFormatFeatureFlagBits2(static_cast<uint64_t>(0)));
    return ret;
}

static inline const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR";
        case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR";
        case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR";
        case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR";
        case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR";
        case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR";
        case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR";
        case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR";
        case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
            return "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR";
        default:
            return "Unhandled VkSurfaceTransformFlagBitsKHR";
    }
}

static inline std::string string_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSurfaceTransformFlagBitsKHR(static_cast<VkSurfaceTransformFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSurfaceTransformFlagBitsKHR(static_cast<VkSurfaceTransformFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkPresentModeKHR(VkPresentModeKHR input_value)
{
    switch (input_value)
    {
        case VK_PRESENT_MODE_FIFO_KHR:
            return "VK_PRESENT_MODE_FIFO_KHR";
        case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
            return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
        case VK_PRESENT_MODE_IMMEDIATE_KHR:
            return "VK_PRESENT_MODE_IMMEDIATE_KHR";
        case VK_PRESENT_MODE_MAILBOX_KHR:
            return "VK_PRESENT_MODE_MAILBOX_KHR";
        case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
            return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
        case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
            return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
        default:
            return "Unhandled VkPresentModeKHR";
    }
}

static inline const char* string_VkColorSpaceKHR(VkColorSpaceKHR input_value)
{
    switch (input_value)
    {
        case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
            return "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT";
        case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
            return "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
        case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
            return "VK_COLOR_SPACE_BT2020_LINEAR_EXT";
        case VK_COLOR_SPACE_BT709_LINEAR_EXT:
            return "VK_COLOR_SPACE_BT709_LINEAR_EXT";
        case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
            return "VK_COLOR_SPACE_BT709_NONLINEAR_EXT";
        case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
            return "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
        case VK_COLOR_SPACE_DISPLAY_NATIVE_AMD:
            return "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD";
        case VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT:
            return "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT";
        case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
            return "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
        case VK_COLOR_SPACE_DOLBYVISION_EXT:
            return "VK_COLOR_SPACE_DOLBYVISION_EXT";
        case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
            return "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
        case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
            return "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
        case VK_COLOR_SPACE_HDR10_HLG_EXT:
            return "VK_COLOR_SPACE_HDR10_HLG_EXT";
        case VK_COLOR_SPACE_HDR10_ST2084_EXT:
            return "VK_COLOR_SPACE_HDR10_ST2084_EXT";
        case VK_COLOR_SPACE_PASS_THROUGH_EXT:
            return "VK_COLOR_SPACE_PASS_THROUGH_EXT";
        case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
            return "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR";
        default:
            return "Unhandled VkColorSpaceKHR";
    }
}

static inline const char* string_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR:
            return "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR";
        case VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR:
            return "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR";
        case VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR:
            return "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR";
        case VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR:
            return "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR";
        default:
            return "Unhandled VkCompositeAlphaFlagBitsKHR";
    }
}

static inline std::string string_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkCompositeAlphaFlagBitsKHR(static_cast<VkCompositeAlphaFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkCompositeAlphaFlagBitsKHR(static_cast<VkCompositeAlphaFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR:
            return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR";
        case VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR:
            return "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR";
        case VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR:
            return "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR";
        default:
            return "Unhandled VkSwapchainCreateFlagBitsKHR";
    }
}

static inline std::string string_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSwapchainCreateFlagBitsKHR(static_cast<VkSwapchainCreateFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSwapchainCreateFlagBitsKHR(static_cast<VkSwapchainCreateFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR:
            return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR";
        case VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR:
            return "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR";
        case VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR:
            return "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR";
        case VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR:
            return "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR";
        default:
            return "Unhandled VkDeviceGroupPresentModeFlagBitsKHR";
    }
}

static inline std::string string_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDeviceGroupPresentModeFlagBitsKHR(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDeviceGroupPresentModeFlagBitsKHR(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR:
            return "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR";
        case VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR:
            return "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR";
        case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR:
            return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR";
        case VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR:
            return "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR";
        default:
            return "Unhandled VkDisplayPlaneAlphaFlagBitsKHR";
    }
}

static inline std::string string_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDisplayPlaneAlphaFlagBitsKHR(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDisplayPlaneAlphaFlagBitsKHR(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(0)));
    return ret;
}


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOperationFlagBitsKHR input_value)
{
    switch (input_value)
    {
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT:
            return "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT:
            return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT:
            return "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT:
            return "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT";
#endif // VK_ENABLE_BETA_EXTENSIONS
        case VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR:
            return "VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR";
        default:
            return "Unhandled VkVideoCodecOperationFlagBitsKHR";
    }
}

static inline std::string string_VkVideoCodecOperationFlagsKHR(VkVideoCodecOperationFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoCodecOperationFlagBitsKHR(static_cast<VkVideoCodecOperationFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoCodecOperationFlagBitsKHR(static_cast<VkVideoCodecOperationFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoChromaSubsamplingFlagBitsKHR(VkVideoChromaSubsamplingFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR:
            return "VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR";
        case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR:
            return "VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR";
        case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR:
            return "VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR";
        case VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR:
            return "VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR";
        case VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR:
            return "VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR";
        default:
            return "Unhandled VkVideoChromaSubsamplingFlagBitsKHR";
    }
}

static inline std::string string_VkVideoChromaSubsamplingFlagsKHR(VkVideoChromaSubsamplingFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoChromaSubsamplingFlagBitsKHR(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoChromaSubsamplingFlagBitsKHR(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoComponentBitDepthFlagBitsKHR(VkVideoComponentBitDepthFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR:
            return "VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR";
        case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR:
            return "VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR";
        case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR:
            return "VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR";
        case VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR:
            return "VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR";
        default:
            return "Unhandled VkVideoComponentBitDepthFlagBitsKHR";
    }
}

static inline std::string string_VkVideoComponentBitDepthFlagsKHR(VkVideoComponentBitDepthFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoComponentBitDepthFlagBitsKHR(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoComponentBitDepthFlagBitsKHR(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoCapabilityFlagBitsKHR(VkVideoCapabilityFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR:
            return "VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR";
        case VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR:
            return "VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR";
        default:
            return "Unhandled VkVideoCapabilityFlagBitsKHR";
    }
}

static inline std::string string_VkVideoCapabilityFlagsKHR(VkVideoCapabilityFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoCapabilityFlagBitsKHR(static_cast<VkVideoCapabilityFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoCapabilityFlagBitsKHR(static_cast<VkVideoCapabilityFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionCreateFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_SESSION_CREATE_DEFAULT_KHR:
            return "VK_VIDEO_SESSION_CREATE_DEFAULT_KHR";
        case VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR:
            return "VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR";
        default:
            return "Unhandled VkVideoSessionCreateFlagBitsKHR";
    }
}

static inline std::string string_VkVideoSessionCreateFlagsKHR(VkVideoSessionCreateFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoSessionCreateFlagBitsKHR(static_cast<VkVideoSessionCreateFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoSessionCreateFlagBitsKHR(static_cast<VkVideoSessionCreateFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoCodingControlFlagBitsKHR(VkVideoCodingControlFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_CODING_CONTROL_DEFAULT_KHR:
            return "VK_VIDEO_CODING_CONTROL_DEFAULT_KHR";
        case VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR:
            return "VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR";
        default:
            return "Unhandled VkVideoCodingControlFlagBitsKHR";
    }
}

static inline std::string string_VkVideoCodingControlFlagsKHR(VkVideoCodingControlFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoCodingControlFlagBitsKHR(static_cast<VkVideoCodingControlFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoCodingControlFlagBitsKHR(static_cast<VkVideoCodingControlFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoCodingQualityPresetFlagBitsKHR(VkVideoCodingQualityPresetFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR:
            return "VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR";
        case VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR:
            return "VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR";
        case VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR:
            return "VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR";
        default:
            return "Unhandled VkVideoCodingQualityPresetFlagBitsKHR";
    }
}

static inline std::string string_VkVideoCodingQualityPresetFlagsKHR(VkVideoCodingQualityPresetFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoCodingQualityPresetFlagBitsKHR(static_cast<VkVideoCodingQualityPresetFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoCodingQualityPresetFlagBitsKHR(static_cast<VkVideoCodingQualityPresetFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkQueryResultStatusKHR(VkQueryResultStatusKHR input_value)
{
    switch (input_value)
    {
        case VK_QUERY_RESULT_STATUS_COMPLETE_KHR:
            return "VK_QUERY_RESULT_STATUS_COMPLETE_KHR";
        case VK_QUERY_RESULT_STATUS_ERROR_KHR:
            return "VK_QUERY_RESULT_STATUS_ERROR_KHR";
        case VK_QUERY_RESULT_STATUS_NOT_READY_KHR:
            return "VK_QUERY_RESULT_STATUS_NOT_READY_KHR";
        default:
            return "Unhandled VkQueryResultStatusKHR";
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoDecodeCapabilityFlagBitsKHR(VkVideoDecodeCapabilityFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_DECODE_CAPABILITY_DEFAULT_KHR:
            return "VK_VIDEO_DECODE_CAPABILITY_DEFAULT_KHR";
        case VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR:
            return "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR";
        case VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR:
            return "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR";
        default:
            return "Unhandled VkVideoDecodeCapabilityFlagBitsKHR";
    }
}

static inline std::string string_VkVideoDecodeCapabilityFlagsKHR(VkVideoDecodeCapabilityFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoDecodeCapabilityFlagBitsKHR(static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoDecodeCapabilityFlagBitsKHR(static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoDecodeFlagBitsKHR(VkVideoDecodeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_DECODE_DEFAULT_KHR:
            return "VK_VIDEO_DECODE_DEFAULT_KHR";
        case VK_VIDEO_DECODE_RESERVED_0_BIT_KHR:
            return "VK_VIDEO_DECODE_RESERVED_0_BIT_KHR";
        default:
            return "Unhandled VkVideoDecodeFlagBitsKHR";
    }
}

static inline std::string string_VkVideoDecodeFlagsKHR(VkVideoDecodeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoDecodeFlagBitsKHR(static_cast<VkVideoDecodeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoDecodeFlagBitsKHR(static_cast<VkVideoDecodeFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkRenderingFlagBitsKHR(VkRenderingFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT:
            return "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT";
        case VK_RENDERING_RESUMING_BIT:
            return "VK_RENDERING_RESUMING_BIT";
        case VK_RENDERING_SUSPENDING_BIT:
            return "VK_RENDERING_SUSPENDING_BIT";
        default:
            return "Unhandled VkRenderingFlagBitsKHR";
    }
}

static inline std::string string_VkRenderingFlagsKHR(VkRenderingFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkRenderingFlagBitsKHR(static_cast<VkRenderingFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkRenderingFlagBitsKHR(static_cast<VkRenderingFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkPeerMemoryFeatureFlagBitsKHR(VkPeerMemoryFeatureFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_PEER_MEMORY_FEATURE_COPY_DST_BIT:
            return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT";
        case VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT:
            return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT";
        case VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT:
            return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT";
        case VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT:
            return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT";
        default:
            return "Unhandled VkPeerMemoryFeatureFlagBitsKHR";
    }
}

static inline std::string string_VkPeerMemoryFeatureFlagsKHR(VkPeerMemoryFeatureFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPeerMemoryFeatureFlagBitsKHR(static_cast<VkPeerMemoryFeatureFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPeerMemoryFeatureFlagBitsKHR(static_cast<VkPeerMemoryFeatureFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkMemoryAllocateFlagBitsKHR(VkMemoryAllocateFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT:
            return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT";
        case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT:
            return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
        case VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT:
            return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT";
        default:
            return "Unhandled VkMemoryAllocateFlagBitsKHR";
    }
}

static inline std::string string_VkMemoryAllocateFlagsKHR(VkMemoryAllocateFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkMemoryAllocateFlagBitsKHR(static_cast<VkMemoryAllocateFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkMemoryAllocateFlagBitsKHR(static_cast<VkMemoryAllocateFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkExternalMemoryHandleTypeFlagBitsKHR(VkExternalMemoryHandleTypeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA";
        default:
            return "Unhandled VkExternalMemoryHandleTypeFlagBitsKHR";
    }
}

static inline std::string string_VkExternalMemoryHandleTypeFlagsKHR(VkExternalMemoryHandleTypeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalMemoryHandleTypeFlagBitsKHR(static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBitsKHR(static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkExternalMemoryFeatureFlagBitsKHR(VkExternalMemoryFeatureFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT:
            return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT";
        case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT:
            return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT";
        case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT:
            return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT";
        default:
            return "Unhandled VkExternalMemoryFeatureFlagBitsKHR";
    }
}

static inline std::string string_VkExternalMemoryFeatureFlagsKHR(VkExternalMemoryFeatureFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalMemoryFeatureFlagBitsKHR(static_cast<VkExternalMemoryFeatureFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBitsKHR(static_cast<VkExternalMemoryFeatureFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkExternalSemaphoreHandleTypeFlagBitsKHR(VkExternalSemaphoreHandleTypeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
        case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA:
            return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA";
        default:
            return "Unhandled VkExternalSemaphoreHandleTypeFlagBitsKHR";
    }
}

static inline std::string string_VkExternalSemaphoreHandleTypeFlagsKHR(VkExternalSemaphoreHandleTypeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalSemaphoreHandleTypeFlagBitsKHR(static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalSemaphoreHandleTypeFlagBitsKHR(static_cast<VkExternalSemaphoreHandleTypeFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkExternalSemaphoreFeatureFlagBitsKHR(VkExternalSemaphoreFeatureFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT:
            return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT";
        case VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT:
            return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT";
        default:
            return "Unhandled VkExternalSemaphoreFeatureFlagBitsKHR";
    }
}

static inline std::string string_VkExternalSemaphoreFeatureFlagsKHR(VkExternalSemaphoreFeatureFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalSemaphoreFeatureFlagBitsKHR(static_cast<VkExternalSemaphoreFeatureFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalSemaphoreFeatureFlagBitsKHR(static_cast<VkExternalSemaphoreFeatureFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkSemaphoreImportFlagBitsKHR(VkSemaphoreImportFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_SEMAPHORE_IMPORT_TEMPORARY_BIT:
            return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
        default:
            return "Unhandled VkSemaphoreImportFlagBitsKHR";
    }
}

static inline std::string string_VkSemaphoreImportFlagsKHR(VkSemaphoreImportFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSemaphoreImportFlagBitsKHR(static_cast<VkSemaphoreImportFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSemaphoreImportFlagBitsKHR(static_cast<VkSemaphoreImportFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkDescriptorUpdateTemplateTypeKHR(VkDescriptorUpdateTemplateTypeKHR input_value)
{
    switch (input_value)
    {
        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
            return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
            return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
        default:
            return "Unhandled VkDescriptorUpdateTemplateTypeKHR";
    }
}

static inline const char* string_VkExternalFenceHandleTypeFlagBitsKHR(VkExternalFenceHandleTypeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT";
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        case VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
            return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT";
        default:
            return "Unhandled VkExternalFenceHandleTypeFlagBitsKHR";
    }
}

static inline std::string string_VkExternalFenceHandleTypeFlagsKHR(VkExternalFenceHandleTypeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalFenceHandleTypeFlagBitsKHR(static_cast<VkExternalFenceHandleTypeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalFenceHandleTypeFlagBitsKHR(static_cast<VkExternalFenceHandleTypeFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkExternalFenceFeatureFlagBitsKHR(VkExternalFenceFeatureFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT:
            return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT";
        case VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT:
            return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT";
        default:
            return "Unhandled VkExternalFenceFeatureFlagBitsKHR";
    }
}

static inline std::string string_VkExternalFenceFeatureFlagsKHR(VkExternalFenceFeatureFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalFenceFeatureFlagBitsKHR(static_cast<VkExternalFenceFeatureFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalFenceFeatureFlagBitsKHR(static_cast<VkExternalFenceFeatureFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkFenceImportFlagBitsKHR(VkFenceImportFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_FENCE_IMPORT_TEMPORARY_BIT:
            return "VK_FENCE_IMPORT_TEMPORARY_BIT";
        default:
            return "Unhandled VkFenceImportFlagBitsKHR";
    }
}

static inline std::string string_VkFenceImportFlagsKHR(VkFenceImportFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkFenceImportFlagBitsKHR(static_cast<VkFenceImportFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkFenceImportFlagBitsKHR(static_cast<VkFenceImportFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR";
        case VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR:
            return "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR";
        default:
            return "Unhandled VkPerformanceCounterUnitKHR";
    }
}

static inline const char* string_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR:
            return "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR";
        case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR:
            return "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR";
        case VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR:
            return "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR";
        default:
            return "Unhandled VkPerformanceCounterScopeKHR";
    }
}

static inline const char* string_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR:
            return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR";
        case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR:
            return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR";
        case VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR:
            return "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR";
        case VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR:
            return "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR";
        case VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR:
            return "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR";
        case VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR:
            return "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR";
        default:
            return "Unhandled VkPerformanceCounterStorageKHR";
    }
}

static inline const char* string_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR:
            return "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR";
        case VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR:
            return "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR";
        default:
            return "Unhandled VkPerformanceCounterDescriptionFlagBitsKHR";
    }
}

static inline std::string string_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPerformanceCounterDescriptionFlagBitsKHR(static_cast<VkPerformanceCounterDescriptionFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPerformanceCounterDescriptionFlagBitsKHR(static_cast<VkPerformanceCounterDescriptionFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkPointClippingBehaviorKHR(VkPointClippingBehaviorKHR input_value)
{
    switch (input_value)
    {
        case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
            return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
        case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
            return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
        default:
            return "Unhandled VkPointClippingBehaviorKHR";
    }
}

static inline const char* string_VkTessellationDomainOriginKHR(VkTessellationDomainOriginKHR input_value)
{
    switch (input_value)
    {
        case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT:
            return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT";
        case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
            return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT";
        default:
            return "Unhandled VkTessellationDomainOriginKHR";
    }
}

static inline const char* string_VkSamplerYcbcrModelConversionKHR(VkSamplerYcbcrModelConversionKHR input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709";
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
            return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY";
        default:
            return "Unhandled VkSamplerYcbcrModelConversionKHR";
    }
}

static inline const char* string_VkSamplerYcbcrRangeKHR(VkSamplerYcbcrRangeKHR input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
            return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL";
        case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
            return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW";
        default:
            return "Unhandled VkSamplerYcbcrRangeKHR";
    }
}

static inline const char* string_VkChromaLocationKHR(VkChromaLocationKHR input_value)
{
    switch (input_value)
    {
        case VK_CHROMA_LOCATION_COSITED_EVEN:
            return "VK_CHROMA_LOCATION_COSITED_EVEN";
        case VK_CHROMA_LOCATION_MIDPOINT:
            return "VK_CHROMA_LOCATION_MIDPOINT";
        default:
            return "Unhandled VkChromaLocationKHR";
    }
}

static inline const char* string_VkQueueGlobalPriorityKHR(VkQueueGlobalPriorityKHR input_value)
{
    switch (input_value)
    {
        case VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR";
        case VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR";
        case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR";
        case VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR";
        default:
            return "Unhandled VkQueueGlobalPriorityKHR";
    }
}

static inline const char* string_VkDriverIdKHR(VkDriverIdKHR input_value)
{
    switch (input_value)
    {
        case VK_DRIVER_ID_AMD_OPEN_SOURCE:
            return "VK_DRIVER_ID_AMD_OPEN_SOURCE";
        case VK_DRIVER_ID_AMD_PROPRIETARY:
            return "VK_DRIVER_ID_AMD_PROPRIETARY";
        case VK_DRIVER_ID_ARM_PROPRIETARY:
            return "VK_DRIVER_ID_ARM_PROPRIETARY";
        case VK_DRIVER_ID_BROADCOM_PROPRIETARY:
            return "VK_DRIVER_ID_BROADCOM_PROPRIETARY";
        case VK_DRIVER_ID_COREAVI_PROPRIETARY:
            return "VK_DRIVER_ID_COREAVI_PROPRIETARY";
        case VK_DRIVER_ID_GGP_PROPRIETARY:
            return "VK_DRIVER_ID_GGP_PROPRIETARY";
        case VK_DRIVER_ID_GOOGLE_SWIFTSHADER:
            return "VK_DRIVER_ID_GOOGLE_SWIFTSHADER";
        case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
            return "VK_DRIVER_ID_IMAGINATION_PROPRIETARY";
        case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
            return "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
        case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
            return "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
        case VK_DRIVER_ID_JUICE_PROPRIETARY:
            return "VK_DRIVER_ID_JUICE_PROPRIETARY";
        case VK_DRIVER_ID_MESA_LLVMPIPE:
            return "VK_DRIVER_ID_MESA_LLVMPIPE";
        case VK_DRIVER_ID_MESA_PANVK:
            return "VK_DRIVER_ID_MESA_PANVK";
        case VK_DRIVER_ID_MESA_RADV:
            return "VK_DRIVER_ID_MESA_RADV";
        case VK_DRIVER_ID_MESA_TURNIP:
            return "VK_DRIVER_ID_MESA_TURNIP";
        case VK_DRIVER_ID_MESA_V3DV:
            return "VK_DRIVER_ID_MESA_V3DV";
        case VK_DRIVER_ID_MESA_VENUS:
            return "VK_DRIVER_ID_MESA_VENUS";
        case VK_DRIVER_ID_MOLTENVK:
            return "VK_DRIVER_ID_MOLTENVK";
        case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
            return "VK_DRIVER_ID_NVIDIA_PROPRIETARY";
        case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
            return "VK_DRIVER_ID_QUALCOMM_PROPRIETARY";
        case VK_DRIVER_ID_SAMSUNG_PROPRIETARY:
            return "VK_DRIVER_ID_SAMSUNG_PROPRIETARY";
        case VK_DRIVER_ID_VERISILICON_PROPRIETARY:
            return "VK_DRIVER_ID_VERISILICON_PROPRIETARY";
        default:
            return "Unhandled VkDriverIdKHR";
    }
}

static inline const char* string_VkShaderFloatControlsIndependenceKHR(VkShaderFloatControlsIndependenceKHR input_value)
{
    switch (input_value)
    {
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY:
            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL:
            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE:
            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
        default:
            return "Unhandled VkShaderFloatControlsIndependenceKHR";
    }
}

static inline const char* string_VkResolveModeFlagBitsKHR(VkResolveModeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_RESOLVE_MODE_AVERAGE_BIT:
            return "VK_RESOLVE_MODE_AVERAGE_BIT";
        case VK_RESOLVE_MODE_MAX_BIT:
            return "VK_RESOLVE_MODE_MAX_BIT";
        case VK_RESOLVE_MODE_MIN_BIT:
            return "VK_RESOLVE_MODE_MIN_BIT";
        case VK_RESOLVE_MODE_NONE:
            return "VK_RESOLVE_MODE_NONE";
        case VK_RESOLVE_MODE_SAMPLE_ZERO_BIT:
            return "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT";
        default:
            return "Unhandled VkResolveModeFlagBitsKHR";
    }
}

static inline std::string string_VkResolveModeFlagsKHR(VkResolveModeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkResolveModeFlagBitsKHR(static_cast<VkResolveModeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkResolveModeFlagBitsKHR(static_cast<VkResolveModeFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkSemaphoreTypeKHR(VkSemaphoreTypeKHR input_value)
{
    switch (input_value)
    {
        case VK_SEMAPHORE_TYPE_BINARY:
            return "VK_SEMAPHORE_TYPE_BINARY";
        case VK_SEMAPHORE_TYPE_TIMELINE:
            return "VK_SEMAPHORE_TYPE_TIMELINE";
        default:
            return "Unhandled VkSemaphoreTypeKHR";
    }
}

static inline const char* string_VkSemaphoreWaitFlagBitsKHR(VkSemaphoreWaitFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_SEMAPHORE_WAIT_ANY_BIT:
            return "VK_SEMAPHORE_WAIT_ANY_BIT";
        default:
            return "Unhandled VkSemaphoreWaitFlagBitsKHR";
    }
}

static inline std::string string_VkSemaphoreWaitFlagsKHR(VkSemaphoreWaitFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSemaphoreWaitFlagBitsKHR(static_cast<VkSemaphoreWaitFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSemaphoreWaitFlagBitsKHR(static_cast<VkSemaphoreWaitFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR input_value)
{
    switch (input_value)
    {
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
            return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR";
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR:
            return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR";
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR:
            return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR";
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR:
            return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR";
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR:
            return "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR";
        default:
            return "Unhandled VkFragmentShadingRateCombinerOpKHR";
    }
}

static inline const char* string_VkPipelineExecutableStatisticFormatKHR(VkPipelineExecutableStatisticFormatKHR input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR:
            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR";
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR:
            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR";
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR:
            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR";
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR:
            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR";
        default:
            return "Unhandled VkPipelineExecutableStatisticFormatKHR";
    }
}


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_DEFAULT_KHR:
            return "VK_VIDEO_ENCODE_DEFAULT_KHR";
        case VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR:
            return "VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR";
        default:
            return "Unhandled VkVideoEncodeFlagBitsKHR";
    }
}

static inline std::string string_VkVideoEncodeFlagsKHR(VkVideoEncodeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeFlagBitsKHR(static_cast<VkVideoEncodeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeFlagBitsKHR(static_cast<VkVideoEncodeFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncodeCapabilityFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_CAPABILITY_DEFAULT_KHR:
            return "VK_VIDEO_ENCODE_CAPABILITY_DEFAULT_KHR";
        case VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR:
            return "VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR";
        default:
            return "Unhandled VkVideoEncodeCapabilityFlagBitsKHR";
    }
}

static inline std::string string_VkVideoEncodeCapabilityFlagsKHR(VkVideoEncodeCapabilityFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeCapabilityFlagBitsKHR(static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeCapabilityFlagBitsKHR(static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeRateControlModeFlagBitsKHR(VkVideoEncodeRateControlModeFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR:
            return "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR";
        case VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR:
            return "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR";
        case VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR:
            return "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR";
        default:
            return "Unhandled VkVideoEncodeRateControlModeFlagBitsKHR";
    }
}

static inline std::string string_VkVideoEncodeRateControlModeFlagsKHR(VkVideoEncodeRateControlModeFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeRateControlModeFlagBitsKHR(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeRateControlModeFlagBitsKHR(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeRateControlFlagBitsKHR(VkVideoEncodeRateControlFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR:
            return "VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR";
        case VK_VIDEO_ENCODE_RATE_CONTROL_RESERVED_0_BIT_KHR:
            return "VK_VIDEO_ENCODE_RATE_CONTROL_RESERVED_0_BIT_KHR";
        default:
            return "Unhandled VkVideoEncodeRateControlFlagBitsKHR";
    }
}

static inline std::string string_VkVideoEncodeRateControlFlagsKHR(VkVideoEncodeRateControlFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeRateControlFlagBitsKHR(static_cast<VkVideoEncodeRateControlFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeRateControlFlagBitsKHR(static_cast<VkVideoEncodeRateControlFlagBitsKHR>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkPipelineStageFlagBits2KHR(uint64_t input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
        case VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR";
        case VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT:
            return "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT";
        case VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT:
            return "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT";
        case VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT:
            return "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT";
        case VK_PIPELINE_STAGE_2_BLIT_BIT:
            return "VK_PIPELINE_STAGE_2_BLIT_BIT";
        case VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT:
            return "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT";
        case VK_PIPELINE_STAGE_2_CLEAR_BIT:
            return "VK_PIPELINE_STAGE_2_CLEAR_BIT";
        case VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT:
            return "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT";
        case VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV:
            return "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV";
        case VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT:
            return "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
        case VK_PIPELINE_STAGE_2_COPY_BIT:
            return "VK_PIPELINE_STAGE_2_COPY_BIT";
        case VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT:
            return "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT";
        case VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT:
            return "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT";
        case VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT:
            return "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
        case VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        case VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_HOST_BIT:
            return "VK_PIPELINE_STAGE_2_HOST_BIT";
        case VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT:
            return "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT";
        case VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI:
            return "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI";
        case VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT:
            return "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT";
        case VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV:
            return "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV";
        case VK_PIPELINE_STAGE_2_NONE:
            return "VK_PIPELINE_STAGE_2_NONE";
        case VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT:
            return "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT";
        case VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR";
        case VK_PIPELINE_STAGE_2_RESOLVE_BIT:
            return "VK_PIPELINE_STAGE_2_RESOLVE_BIT";
        case VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI:
            return "VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI";
        case VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV:
            return "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV";
        case VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT";
        case VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT:
            return "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT";
        case VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT:
            return "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT";
        case VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT:
            return "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT";
        case VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT:
            return "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT";
        case VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT:
            return "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR:
            return "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkPipelineStageFlagBits2KHR";
    }
}

static inline std::string string_VkPipelineStageFlags2KHR(VkPipelineStageFlags2KHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineStageFlagBits2KHR(static_cast<uint64_t>(1ULL << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineStageFlagBits2KHR(static_cast<uint64_t>(0)));
    return ret;
}

static inline const char* string_VkAccessFlagBits2KHR(uint64_t input_value)
{
    switch (input_value)
    {
        case VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR:
            return "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR";
        case VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR:
            return "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
        case VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT";
        case VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT:
            return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
        case VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT:
            return "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT";
        case VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV:
            return "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV";
        case VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV:
            return "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV";
        case VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT:
            return "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT";
        case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
        case VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT:
            return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
        case VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT:
            return "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
        case VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
            return "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
        case VK_ACCESS_2_HOST_READ_BIT:
            return "VK_ACCESS_2_HOST_READ_BIT";
        case VK_ACCESS_2_HOST_WRITE_BIT:
            return "VK_ACCESS_2_HOST_WRITE_BIT";
        case VK_ACCESS_2_INDEX_READ_BIT:
            return "VK_ACCESS_2_INDEX_READ_BIT";
        case VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT:
            return "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT";
        case VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT:
            return "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT";
        case VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI:
            return "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI";
        case VK_ACCESS_2_MEMORY_READ_BIT:
            return "VK_ACCESS_2_MEMORY_READ_BIT";
        case VK_ACCESS_2_MEMORY_WRITE_BIT:
            return "VK_ACCESS_2_MEMORY_WRITE_BIT";
        case VK_ACCESS_2_NONE:
            return "VK_ACCESS_2_NONE";
        case VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR:
            return "VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR";
        case VK_ACCESS_2_SHADER_READ_BIT:
            return "VK_ACCESS_2_SHADER_READ_BIT";
        case VK_ACCESS_2_SHADER_SAMPLED_READ_BIT:
            return "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT";
        case VK_ACCESS_2_SHADER_STORAGE_READ_BIT:
            return "VK_ACCESS_2_SHADER_STORAGE_READ_BIT";
        case VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT:
            return "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT";
        case VK_ACCESS_2_SHADER_WRITE_BIT:
            return "VK_ACCESS_2_SHADER_WRITE_BIT";
        case VK_ACCESS_2_TRANSFER_READ_BIT:
            return "VK_ACCESS_2_TRANSFER_READ_BIT";
        case VK_ACCESS_2_TRANSFER_WRITE_BIT:
            return "VK_ACCESS_2_TRANSFER_WRITE_BIT";
        case VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT:
            return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
        case VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT:
            return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
        case VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT:
            return "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
        case VK_ACCESS_2_UNIFORM_READ_BIT:
            return "VK_ACCESS_2_UNIFORM_READ_BIT";
        case VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT:
            return "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR:
            return "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkAccessFlagBits2KHR";
    }
}

static inline std::string string_VkAccessFlags2KHR(VkAccessFlags2KHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkAccessFlagBits2KHR(static_cast<uint64_t>(1ULL << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkAccessFlagBits2KHR(static_cast<uint64_t>(0)));
    return ret;
}

static inline const char* string_VkSubmitFlagBitsKHR(VkSubmitFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_SUBMIT_PROTECTED_BIT:
            return "VK_SUBMIT_PROTECTED_BIT";
        default:
            return "Unhandled VkSubmitFlagBitsKHR";
    }
}

static inline std::string string_VkSubmitFlagsKHR(VkSubmitFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSubmitFlagBitsKHR(static_cast<VkSubmitFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSubmitFlagBitsKHR(static_cast<VkSubmitFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkFormatFeatureFlagBits2KHR(uint64_t input_value)
{
    switch (input_value)
    {
        case VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR";
        case VK_FORMAT_FEATURE_2_BLIT_DST_BIT:
            return "VK_FORMAT_FEATURE_2_BLIT_DST_BIT";
        case VK_FORMAT_FEATURE_2_BLIT_SRC_BIT:
            return "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT";
        case VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT:
            return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT";
        case VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT:
            return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT";
        case VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT:
            return "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT";
        case VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT:
            return "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT";
        case VK_FORMAT_FEATURE_2_DISJOINT_BIT:
            return "VK_FORMAT_FEATURE_2_DISJOINT_BIT";
        case VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT:
            return "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT";
        case VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        case VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV:
            return "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV";
        case VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT:
            return "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT";
        case VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT:
            return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT";
        case VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT:
            return "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT";
        case VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT:
            return "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT";
        case VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT:
            return "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT";
        case VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT:
            return "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT";
        case VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT:
            return "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT";
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
#ifdef VK_ENABLE_BETA_EXTENSIONS
        case VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR:
            return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR";
#endif // VK_ENABLE_BETA_EXTENSIONS
        default:
            return "Unhandled VkFormatFeatureFlagBits2KHR";
    }
}

static inline std::string string_VkFormatFeatureFlags2KHR(VkFormatFeatureFlags2KHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkFormatFeatureFlagBits2KHR(static_cast<uint64_t>(1ULL << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkFormatFeatureFlagBits2KHR(static_cast<uint64_t>(0)));
    return ret;
}

static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
            return "VK_DEBUG_REPORT_DEBUG_BIT_EXT";
        case VK_DEBUG_REPORT_ERROR_BIT_EXT:
            return "VK_DEBUG_REPORT_ERROR_BIT_EXT";
        case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
            return "VK_DEBUG_REPORT_INFORMATION_BIT_EXT";
        case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
            return "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT";
        case VK_DEBUG_REPORT_WARNING_BIT_EXT:
            return "VK_DEBUG_REPORT_WARNING_BIT_EXT";
        default:
            return "Unhandled VkDebugReportFlagBitsEXT";
    }
}

static inline std::string string_VkDebugReportFlagsEXT(VkDebugReportFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDebugReportFlagBitsEXT(static_cast<VkDebugReportFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDebugReportFlagBitsEXT(static_cast<VkDebugReportFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value)
{
    switch (input_value)
    {
        case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT";
        case VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT:
            return "VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT";
        default:
            return "Unhandled VkDebugReportObjectTypeEXT";
    }
}

static inline const char* string_VkRasterizationOrderAMD(VkRasterizationOrderAMD input_value)
{
    switch (input_value)
    {
        case VK_RASTERIZATION_ORDER_RELAXED_AMD:
            return "VK_RASTERIZATION_ORDER_RELAXED_AMD";
        case VK_RASTERIZATION_ORDER_STRICT_AMD:
            return "VK_RASTERIZATION_ORDER_STRICT_AMD";
        default:
            return "Unhandled VkRasterizationOrderAMD";
    }
}


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH264CapabilityFlagBitsEXT(VkVideoEncodeH264CapabilityFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH264CapabilityFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH264CapabilityFlagsEXT(VkVideoEncodeH264CapabilityFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH264CapabilityFlagBitsEXT(static_cast<VkVideoEncodeH264CapabilityFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH264CapabilityFlagBitsEXT(static_cast<VkVideoEncodeH264CapabilityFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH264InputModeFlagBitsEXT(VkVideoEncodeH264InputModeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH264InputModeFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH264InputModeFlagsEXT(VkVideoEncodeH264InputModeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH264InputModeFlagBitsEXT(static_cast<VkVideoEncodeH264InputModeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH264InputModeFlagBitsEXT(static_cast<VkVideoEncodeH264InputModeFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH264OutputModeFlagBitsEXT(VkVideoEncodeH264OutputModeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH264OutputModeFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH264OutputModeFlagsEXT(VkVideoEncodeH264OutputModeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH264OutputModeFlagBitsEXT(static_cast<VkVideoEncodeH264OutputModeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH264OutputModeFlagBitsEXT(static_cast<VkVideoEncodeH264OutputModeFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH264RateControlStructureFlagBitsEXT(VkVideoEncodeH264RateControlStructureFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT";
        case VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT:
            return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT";
        default:
            return "Unhandled VkVideoEncodeH264RateControlStructureFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH264RateControlStructureFlagsEXT(VkVideoEncodeH264RateControlStructureFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH264RateControlStructureFlagBitsEXT(static_cast<VkVideoEncodeH264RateControlStructureFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH264RateControlStructureFlagBitsEXT(static_cast<VkVideoEncodeH264RateControlStructureFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH265CapabilityFlagBitsEXT(VkVideoEncodeH265CapabilityFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH265CapabilityFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH265CapabilityFlagsEXT(VkVideoEncodeH265CapabilityFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH265CapabilityFlagBitsEXT(static_cast<VkVideoEncodeH265CapabilityFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH265CapabilityFlagBitsEXT(static_cast<VkVideoEncodeH265CapabilityFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH265InputModeFlagBitsEXT(VkVideoEncodeH265InputModeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH265InputModeFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH265InputModeFlagsEXT(VkVideoEncodeH265InputModeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH265InputModeFlagBitsEXT(static_cast<VkVideoEncodeH265InputModeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH265InputModeFlagBitsEXT(static_cast<VkVideoEncodeH265InputModeFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH265OutputModeFlagBitsEXT(VkVideoEncodeH265OutputModeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH265OutputModeFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH265OutputModeFlagsEXT(VkVideoEncodeH265OutputModeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH265OutputModeFlagBitsEXT(static_cast<VkVideoEncodeH265OutputModeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH265OutputModeFlagBitsEXT(static_cast<VkVideoEncodeH265OutputModeFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH265CtbSizeFlagBitsEXT(VkVideoEncodeH265CtbSizeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH265CtbSizeFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH265CtbSizeFlagsEXT(VkVideoEncodeH265CtbSizeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH265CtbSizeFlagBitsEXT(static_cast<VkVideoEncodeH265CtbSizeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH265CtbSizeFlagBitsEXT(static_cast<VkVideoEncodeH265CtbSizeFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH265TransformBlockSizeFlagBitsEXT(VkVideoEncodeH265TransformBlockSizeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT";
        default:
            return "Unhandled VkVideoEncodeH265TransformBlockSizeFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH265TransformBlockSizeFlagsEXT(VkVideoEncodeH265TransformBlockSizeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH265TransformBlockSizeFlagBitsEXT(static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH265TransformBlockSizeFlagBitsEXT(static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoEncodeH265RateControlStructureFlagBitsEXT(VkVideoEncodeH265RateControlStructureFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT:
            return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_BIT_EXT";
        case VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT:
            return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT";
        default:
            return "Unhandled VkVideoEncodeH265RateControlStructureFlagBitsEXT";
    }
}

static inline std::string string_VkVideoEncodeH265RateControlStructureFlagsEXT(VkVideoEncodeH265RateControlStructureFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoEncodeH265RateControlStructureFlagBitsEXT(static_cast<VkVideoEncodeH265RateControlStructureFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoEncodeH265RateControlStructureFlagBitsEXT(static_cast<VkVideoEncodeH265RateControlStructureFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS


#ifdef VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkVideoDecodeH264PictureLayoutFlagBitsEXT(VkVideoDecodeH264PictureLayoutFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT:
            return "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT";
        case VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT:
            return "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT";
        case VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT:
            return "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT";
        default:
            return "Unhandled VkVideoDecodeH264PictureLayoutFlagBitsEXT";
    }
}

static inline std::string string_VkVideoDecodeH264PictureLayoutFlagsEXT(VkVideoDecodeH264PictureLayoutFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkVideoDecodeH264PictureLayoutFlagBitsEXT(static_cast<VkVideoDecodeH264PictureLayoutFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkVideoDecodeH264PictureLayoutFlagBitsEXT(static_cast<VkVideoDecodeH264PictureLayoutFlagBitsEXT>(0)));
    return ret;
}
#endif // VK_ENABLE_BETA_EXTENSIONS

static inline const char* string_VkShaderInfoTypeAMD(VkShaderInfoTypeAMD input_value)
{
    switch (input_value)
    {
        case VK_SHADER_INFO_TYPE_BINARY_AMD:
            return "VK_SHADER_INFO_TYPE_BINARY_AMD";
        case VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD:
            return "VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD";
        case VK_SHADER_INFO_TYPE_STATISTICS_AMD:
            return "VK_SHADER_INFO_TYPE_STATISTICS_AMD";
        default:
            return "Unhandled VkShaderInfoTypeAMD";
    }
}

static inline const char* string_VkExternalMemoryHandleTypeFlagBitsNV(VkExternalMemoryHandleTypeFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV";
        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV:
            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV";
        default:
            return "Unhandled VkExternalMemoryHandleTypeFlagBitsNV";
    }
}

static inline std::string string_VkExternalMemoryHandleTypeFlagsNV(VkExternalMemoryHandleTypeFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalMemoryHandleTypeFlagBitsNV(static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalMemoryHandleTypeFlagBitsNV(static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkExternalMemoryFeatureFlagBitsNV(VkExternalMemoryFeatureFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV:
            return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV";
        case VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV:
            return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV";
        case VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV:
            return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV";
        default:
            return "Unhandled VkExternalMemoryFeatureFlagBitsNV";
    }
}

static inline std::string string_VkExternalMemoryFeatureFlagsNV(VkExternalMemoryFeatureFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkExternalMemoryFeatureFlagBitsNV(static_cast<VkExternalMemoryFeatureFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkExternalMemoryFeatureFlagBitsNV(static_cast<VkExternalMemoryFeatureFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkValidationCheckEXT(VkValidationCheckEXT input_value)
{
    switch (input_value)
    {
        case VK_VALIDATION_CHECK_ALL_EXT:
            return "VK_VALIDATION_CHECK_ALL_EXT";
        case VK_VALIDATION_CHECK_SHADERS_EXT:
            return "VK_VALIDATION_CHECK_SHADERS_EXT";
        default:
            return "Unhandled VkValidationCheckEXT";
    }
}

static inline const char* string_VkConditionalRenderingFlagBitsEXT(VkConditionalRenderingFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT:
            return "VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT";
        default:
            return "Unhandled VkConditionalRenderingFlagBitsEXT";
    }
}

static inline std::string string_VkConditionalRenderingFlagsEXT(VkConditionalRenderingFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkConditionalRenderingFlagBitsEXT(static_cast<VkConditionalRenderingFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkConditionalRenderingFlagBitsEXT(static_cast<VkConditionalRenderingFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_SURFACE_COUNTER_VBLANK_BIT_EXT:
            return "VK_SURFACE_COUNTER_VBLANK_BIT_EXT";
        default:
            return "Unhandled VkSurfaceCounterFlagBitsEXT";
    }
}

static inline std::string string_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkSurfaceCounterFlagBitsEXT(static_cast<VkSurfaceCounterFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkSurfaceCounterFlagBitsEXT(static_cast<VkSurfaceCounterFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value)
{
    switch (input_value)
    {
        case VK_DISPLAY_POWER_STATE_OFF_EXT:
            return "VK_DISPLAY_POWER_STATE_OFF_EXT";
        case VK_DISPLAY_POWER_STATE_ON_EXT:
            return "VK_DISPLAY_POWER_STATE_ON_EXT";
        case VK_DISPLAY_POWER_STATE_SUSPEND_EXT:
            return "VK_DISPLAY_POWER_STATE_SUSPEND_EXT";
        default:
            return "Unhandled VkDisplayPowerStateEXT";
    }
}

static inline const char* string_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT input_value)
{
    switch (input_value)
    {
        case VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT:
            return "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT";
        default:
            return "Unhandled VkDeviceEventTypeEXT";
    }
}

static inline const char* string_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT input_value)
{
    switch (input_value)
    {
        case VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT:
            return "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT";
        default:
            return "Unhandled VkDisplayEventTypeEXT";
    }
}

static inline const char* string_VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV input_value)
{
    switch (input_value)
    {
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV";
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV";
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV";
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV";
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV";
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV";
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV";
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV:
            return "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV";
        default:
            return "Unhandled VkViewportCoordinateSwizzleNV";
    }
}

static inline const char* string_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT input_value)
{
    switch (input_value)
    {
        case VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT:
            return "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT";
        case VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT:
            return "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT";
        default:
            return "Unhandled VkDiscardRectangleModeEXT";
    }
}

static inline const char* string_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT input_value)
{
    switch (input_value)
    {
        case VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT:
            return "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT";
        case VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT:
            return "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT";
        case VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT:
            return "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT";
        default:
            return "Unhandled VkConservativeRasterizationModeEXT";
    }
}

static inline const char* string_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
            return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT";
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
            return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT";
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
            return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT";
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
            return "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT";
        default:
            return "Unhandled VkDebugUtilsMessageSeverityFlagBitsEXT";
    }
}

static inline std::string string_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
            return "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT";
        case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
            return "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT";
        case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT:
            return "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT";
        default:
            return "Unhandled VkDebugUtilsMessageTypeFlagBitsEXT";
    }
}

static inline std::string string_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkSamplerReductionModeEXT(VkSamplerReductionModeEXT input_value)
{
    switch (input_value)
    {
        case VK_SAMPLER_REDUCTION_MODE_MAX:
            return "VK_SAMPLER_REDUCTION_MODE_MAX";
        case VK_SAMPLER_REDUCTION_MODE_MIN:
            return "VK_SAMPLER_REDUCTION_MODE_MIN";
        case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE:
            return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE";
        default:
            return "Unhandled VkSamplerReductionModeEXT";
    }
}

static inline const char* string_VkBlendOverlapEXT(VkBlendOverlapEXT input_value)
{
    switch (input_value)
    {
        case VK_BLEND_OVERLAP_CONJOINT_EXT:
            return "VK_BLEND_OVERLAP_CONJOINT_EXT";
        case VK_BLEND_OVERLAP_DISJOINT_EXT:
            return "VK_BLEND_OVERLAP_DISJOINT_EXT";
        case VK_BLEND_OVERLAP_UNCORRELATED_EXT:
            return "VK_BLEND_OVERLAP_UNCORRELATED_EXT";
        default:
            return "Unhandled VkBlendOverlapEXT";
    }
}

static inline const char* string_VkCoverageModulationModeNV(VkCoverageModulationModeNV input_value)
{
    switch (input_value)
    {
        case VK_COVERAGE_MODULATION_MODE_ALPHA_NV:
            return "VK_COVERAGE_MODULATION_MODE_ALPHA_NV";
        case VK_COVERAGE_MODULATION_MODE_NONE_NV:
            return "VK_COVERAGE_MODULATION_MODE_NONE_NV";
        case VK_COVERAGE_MODULATION_MODE_RGBA_NV:
            return "VK_COVERAGE_MODULATION_MODE_RGBA_NV";
        case VK_COVERAGE_MODULATION_MODE_RGB_NV:
            return "VK_COVERAGE_MODULATION_MODE_RGB_NV";
        default:
            return "Unhandled VkCoverageModulationModeNV";
    }
}

static inline const char* string_VkValidationCacheHeaderVersionEXT(VkValidationCacheHeaderVersionEXT input_value)
{
    switch (input_value)
    {
        case VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT:
            return "VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT";
        default:
            return "Unhandled VkValidationCacheHeaderVersionEXT";
    }
}

static inline const char* string_VkDescriptorBindingFlagBitsEXT(VkDescriptorBindingFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT:
            return "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT";
        case VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT:
            return "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT";
        case VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT:
            return "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT";
        case VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT:
            return "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT";
        default:
            return "Unhandled VkDescriptorBindingFlagBitsEXT";
    }
}

static inline std::string string_VkDescriptorBindingFlagsEXT(VkDescriptorBindingFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDescriptorBindingFlagBitsEXT(static_cast<VkDescriptorBindingFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDescriptorBindingFlagBitsEXT(static_cast<VkDescriptorBindingFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkShadingRatePaletteEntryNV(VkShadingRatePaletteEntryNV input_value)
{
    switch (input_value)
    {
        case VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV";
        case VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV:
            return "VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV";
        default:
            return "Unhandled VkShadingRatePaletteEntryNV";
    }
}

static inline const char* string_VkCoarseSampleOrderTypeNV(VkCoarseSampleOrderTypeNV input_value)
{
    switch (input_value)
    {
        case VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV:
            return "VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV";
        case VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV:
            return "VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV";
        case VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV:
            return "VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV";
        case VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV:
            return "VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV";
        default:
            return "Unhandled VkCoarseSampleOrderTypeNV";
    }
}

static inline const char* string_VkRayTracingShaderGroupTypeKHR(VkRayTracingShaderGroupTypeKHR input_value)
{
    switch (input_value)
    {
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR:
            return "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR";
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR:
            return "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR";
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR:
            return "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR";
        default:
            return "Unhandled VkRayTracingShaderGroupTypeKHR";
    }
}

static inline const char* string_VkRayTracingShaderGroupTypeNV(VkRayTracingShaderGroupTypeNV input_value)
{
    switch (input_value)
    {
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR:
            return "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR";
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR:
            return "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR";
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR:
            return "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR";
        default:
            return "Unhandled VkRayTracingShaderGroupTypeNV";
    }
}

static inline const char* string_VkGeometryTypeKHR(VkGeometryTypeKHR input_value)
{
    switch (input_value)
    {
        case VK_GEOMETRY_TYPE_AABBS_KHR:
            return "VK_GEOMETRY_TYPE_AABBS_KHR";
        case VK_GEOMETRY_TYPE_INSTANCES_KHR:
            return "VK_GEOMETRY_TYPE_INSTANCES_KHR";
        case VK_GEOMETRY_TYPE_TRIANGLES_KHR:
            return "VK_GEOMETRY_TYPE_TRIANGLES_KHR";
        default:
            return "Unhandled VkGeometryTypeKHR";
    }
}

static inline const char* string_VkGeometryTypeNV(VkGeometryTypeNV input_value)
{
    switch (input_value)
    {
        case VK_GEOMETRY_TYPE_AABBS_KHR:
            return "VK_GEOMETRY_TYPE_AABBS_KHR";
        case VK_GEOMETRY_TYPE_INSTANCES_KHR:
            return "VK_GEOMETRY_TYPE_INSTANCES_KHR";
        case VK_GEOMETRY_TYPE_TRIANGLES_KHR:
            return "VK_GEOMETRY_TYPE_TRIANGLES_KHR";
        default:
            return "Unhandled VkGeometryTypeNV";
    }
}

static inline const char* string_VkAccelerationStructureTypeKHR(VkAccelerationStructureTypeKHR input_value)
{
    switch (input_value)
    {
        case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR:
            return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR";
        case VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR:
            return "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR";
        case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR:
            return "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR";
        default:
            return "Unhandled VkAccelerationStructureTypeKHR";
    }
}

static inline const char* string_VkAccelerationStructureTypeNV(VkAccelerationStructureTypeNV input_value)
{
    switch (input_value)
    {
        case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR:
            return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR";
        case VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR:
            return "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR";
        case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR:
            return "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR";
        default:
            return "Unhandled VkAccelerationStructureTypeNV";
    }
}

static inline const char* string_VkGeometryFlagBitsKHR(VkGeometryFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR:
            return "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR";
        case VK_GEOMETRY_OPAQUE_BIT_KHR:
            return "VK_GEOMETRY_OPAQUE_BIT_KHR";
        default:
            return "Unhandled VkGeometryFlagBitsKHR";
    }
}

static inline std::string string_VkGeometryFlagsKHR(VkGeometryFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkGeometryFlagBitsKHR(static_cast<VkGeometryFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkGeometryFlagBitsKHR(static_cast<VkGeometryFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkGeometryFlagBitsNV(VkGeometryFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR:
            return "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR";
        case VK_GEOMETRY_OPAQUE_BIT_KHR:
            return "VK_GEOMETRY_OPAQUE_BIT_KHR";
        default:
            return "Unhandled VkGeometryFlagBitsNV";
    }
}

static inline std::string string_VkGeometryFlagsNV(VkGeometryFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkGeometryFlagBitsNV(static_cast<VkGeometryFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkGeometryFlagBitsNV(static_cast<VkGeometryFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanceFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR";
        case VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR";
        case VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR";
        case VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR";
        default:
            return "Unhandled VkGeometryInstanceFlagBitsKHR";
    }
}

static inline std::string string_VkGeometryInstanceFlagsKHR(VkGeometryInstanceFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkGeometryInstanceFlagBitsKHR(static_cast<VkGeometryInstanceFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkGeometryInstanceFlagBitsKHR(static_cast<VkGeometryInstanceFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkGeometryInstanceFlagBitsNV(VkGeometryInstanceFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR";
        case VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR";
        case VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR";
        case VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR:
            return "VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR";
        default:
            return "Unhandled VkGeometryInstanceFlagBitsNV";
    }
}

static inline std::string string_VkGeometryInstanceFlagsNV(VkGeometryInstanceFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkGeometryInstanceFlagBitsNV(static_cast<VkGeometryInstanceFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkGeometryInstanceFlagBitsNV(static_cast<VkGeometryInstanceFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkBuildAccelerationStructureFlagBitsKHR(VkBuildAccelerationStructureFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV:
            return "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV";
        case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR";
        default:
            return "Unhandled VkBuildAccelerationStructureFlagBitsKHR";
    }
}

static inline std::string string_VkBuildAccelerationStructureFlagsKHR(VkBuildAccelerationStructureFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkBuildAccelerationStructureFlagBitsKHR(static_cast<VkBuildAccelerationStructureFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkBuildAccelerationStructureFlagBitsKHR(static_cast<VkBuildAccelerationStructureFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkBuildAccelerationStructureFlagBitsNV(VkBuildAccelerationStructureFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV:
            return "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV";
        case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR";
        default:
            return "Unhandled VkBuildAccelerationStructureFlagBitsNV";
    }
}

static inline std::string string_VkBuildAccelerationStructureFlagsNV(VkBuildAccelerationStructureFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkBuildAccelerationStructureFlagBitsNV(static_cast<VkBuildAccelerationStructureFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkBuildAccelerationStructureFlagBitsNV(static_cast<VkBuildAccelerationStructureFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkCopyAccelerationStructureModeKHR(VkCopyAccelerationStructureModeKHR input_value)
{
    switch (input_value)
    {
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR";
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR";
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR";
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR";
        default:
            return "Unhandled VkCopyAccelerationStructureModeKHR";
    }
}

static inline const char* string_VkCopyAccelerationStructureModeNV(VkCopyAccelerationStructureModeNV input_value)
{
    switch (input_value)
    {
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR";
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR";
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR";
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR:
            return "VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR";
        default:
            return "Unhandled VkCopyAccelerationStructureModeNV";
    }
}

static inline const char* string_VkAccelerationStructureMemoryRequirementsTypeNV(VkAccelerationStructureMemoryRequirementsTypeNV input_value)
{
    switch (input_value)
    {
        case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV:
            return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV";
        case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV:
            return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV";
        case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV:
            return "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV";
        default:
            return "Unhandled VkAccelerationStructureMemoryRequirementsTypeNV";
    }
}

static inline const char* string_VkQueueGlobalPriorityEXT(VkQueueGlobalPriorityEXT input_value)
{
    switch (input_value)
    {
        case VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR";
        case VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR";
        case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR";
        case VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR:
            return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR";
        default:
            return "Unhandled VkQueueGlobalPriorityEXT";
    }
}

static inline const char* string_VkTimeDomainEXT(VkTimeDomainEXT input_value)
{
    switch (input_value)
    {
        case VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT:
            return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT";
        case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT:
            return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT";
        case VK_TIME_DOMAIN_DEVICE_EXT:
            return "VK_TIME_DOMAIN_DEVICE_EXT";
        case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT:
            return "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT";
        default:
            return "Unhandled VkTimeDomainEXT";
    }
}

static inline const char* string_VkMemoryOverallocationBehaviorAMD(VkMemoryOverallocationBehaviorAMD input_value)
{
    switch (input_value)
    {
        case VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD:
            return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD";
        case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD:
            return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD";
        case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD:
            return "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD";
        default:
            return "Unhandled VkMemoryOverallocationBehaviorAMD";
    }
}

static inline const char* string_VkPipelineCreationFeedbackFlagBitsEXT(VkPipelineCreationFeedbackFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT:
            return "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT";
        case VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT:
            return "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT";
        case VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT:
            return "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT";
        default:
            return "Unhandled VkPipelineCreationFeedbackFlagBitsEXT";
    }
}

static inline std::string string_VkPipelineCreationFeedbackFlagsEXT(VkPipelineCreationFeedbackFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkPipelineCreationFeedbackFlagBitsEXT(static_cast<VkPipelineCreationFeedbackFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkPipelineCreationFeedbackFlagBitsEXT(static_cast<VkPipelineCreationFeedbackFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkPerformanceConfigurationTypeINTEL(VkPerformanceConfigurationTypeINTEL input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL:
            return "VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL";
        default:
            return "Unhandled VkPerformanceConfigurationTypeINTEL";
    }
}

static inline const char* string_VkQueryPoolSamplingModeINTEL(VkQueryPoolSamplingModeINTEL input_value)
{
    switch (input_value)
    {
        case VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL:
            return "VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL";
        default:
            return "Unhandled VkQueryPoolSamplingModeINTEL";
    }
}

static inline const char* string_VkPerformanceOverrideTypeINTEL(VkPerformanceOverrideTypeINTEL input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL:
            return "VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL";
        case VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL:
            return "VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL";
        default:
            return "Unhandled VkPerformanceOverrideTypeINTEL";
    }
}

static inline const char* string_VkPerformanceParameterTypeINTEL(VkPerformanceParameterTypeINTEL input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL:
            return "VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL";
        case VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL:
            return "VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL";
        default:
            return "Unhandled VkPerformanceParameterTypeINTEL";
    }
}

static inline const char* string_VkPerformanceValueTypeINTEL(VkPerformanceValueTypeINTEL input_value)
{
    switch (input_value)
    {
        case VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL:
            return "VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL";
        case VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL:
            return "VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL";
        case VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL:
            return "VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL";
        case VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL:
            return "VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL";
        case VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL:
            return "VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL";
        default:
            return "Unhandled VkPerformanceValueTypeINTEL";
    }
}

static inline const char* string_VkToolPurposeFlagBitsEXT(VkToolPurposeFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT:
            return "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT";
        case VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT:
            return "VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT";
        case VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT:
            return "VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT";
        case VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT:
            return "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT";
        case VK_TOOL_PURPOSE_PROFILING_BIT:
            return "VK_TOOL_PURPOSE_PROFILING_BIT";
        case VK_TOOL_PURPOSE_TRACING_BIT:
            return "VK_TOOL_PURPOSE_TRACING_BIT";
        case VK_TOOL_PURPOSE_VALIDATION_BIT:
            return "VK_TOOL_PURPOSE_VALIDATION_BIT";
        default:
            return "Unhandled VkToolPurposeFlagBitsEXT";
    }
}

static inline std::string string_VkToolPurposeFlagsEXT(VkToolPurposeFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkToolPurposeFlagBitsEXT(static_cast<VkToolPurposeFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkToolPurposeFlagBitsEXT(static_cast<VkToolPurposeFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT input_value)
{
    switch (input_value)
    {
        case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT:
            return "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT";
        case VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT:
            return "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT";
        case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT:
            return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT";
        case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT:
            return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT";
        case VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT:
            return "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT";
        default:
            return "Unhandled VkValidationFeatureEnableEXT";
    }
}

static inline const char* string_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT input_value)
{
    switch (input_value)
    {
        case VK_VALIDATION_FEATURE_DISABLE_ALL_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT";
        case VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT";
        case VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT";
        case VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT";
        case VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT";
        case VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT";
        case VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT";
        case VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT:
            return "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT";
        default:
            return "Unhandled VkValidationFeatureDisableEXT";
    }
}

static inline const char* string_VkComponentTypeNV(VkComponentTypeNV input_value)
{
    switch (input_value)
    {
        case VK_COMPONENT_TYPE_FLOAT16_NV:
            return "VK_COMPONENT_TYPE_FLOAT16_NV";
        case VK_COMPONENT_TYPE_FLOAT32_NV:
            return "VK_COMPONENT_TYPE_FLOAT32_NV";
        case VK_COMPONENT_TYPE_FLOAT64_NV:
            return "VK_COMPONENT_TYPE_FLOAT64_NV";
        case VK_COMPONENT_TYPE_SINT16_NV:
            return "VK_COMPONENT_TYPE_SINT16_NV";
        case VK_COMPONENT_TYPE_SINT32_NV:
            return "VK_COMPONENT_TYPE_SINT32_NV";
        case VK_COMPONENT_TYPE_SINT64_NV:
            return "VK_COMPONENT_TYPE_SINT64_NV";
        case VK_COMPONENT_TYPE_SINT8_NV:
            return "VK_COMPONENT_TYPE_SINT8_NV";
        case VK_COMPONENT_TYPE_UINT16_NV:
            return "VK_COMPONENT_TYPE_UINT16_NV";
        case VK_COMPONENT_TYPE_UINT32_NV:
            return "VK_COMPONENT_TYPE_UINT32_NV";
        case VK_COMPONENT_TYPE_UINT64_NV:
            return "VK_COMPONENT_TYPE_UINT64_NV";
        case VK_COMPONENT_TYPE_UINT8_NV:
            return "VK_COMPONENT_TYPE_UINT8_NV";
        default:
            return "Unhandled VkComponentTypeNV";
    }
}

static inline const char* string_VkScopeNV(VkScopeNV input_value)
{
    switch (input_value)
    {
        case VK_SCOPE_DEVICE_NV:
            return "VK_SCOPE_DEVICE_NV";
        case VK_SCOPE_QUEUE_FAMILY_NV:
            return "VK_SCOPE_QUEUE_FAMILY_NV";
        case VK_SCOPE_SUBGROUP_NV:
            return "VK_SCOPE_SUBGROUP_NV";
        case VK_SCOPE_WORKGROUP_NV:
            return "VK_SCOPE_WORKGROUP_NV";
        default:
            return "Unhandled VkScopeNV";
    }
}

static inline const char* string_VkCoverageReductionModeNV(VkCoverageReductionModeNV input_value)
{
    switch (input_value)
    {
        case VK_COVERAGE_REDUCTION_MODE_MERGE_NV:
            return "VK_COVERAGE_REDUCTION_MODE_MERGE_NV";
        case VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV:
            return "VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV";
        default:
            return "Unhandled VkCoverageReductionModeNV";
    }
}

static inline const char* string_VkProvokingVertexModeEXT(VkProvokingVertexModeEXT input_value)
{
    switch (input_value)
    {
        case VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT:
            return "VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT";
        case VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT:
            return "VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT";
        default:
            return "Unhandled VkProvokingVertexModeEXT";
    }
}


#ifdef VK_USE_PLATFORM_WIN32_KHR

static inline const char* string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveEXT input_value)
{
    switch (input_value)
    {
        case VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT:
            return "VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT";
        case VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT:
            return "VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT";
        case VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT:
            return "VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT";
        case VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT:
            return "VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT";
        default:
            return "Unhandled VkFullScreenExclusiveEXT";
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR

static inline const char* string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value)
{
    switch (input_value)
    {
        case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT:
            return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT";
        case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT:
            return "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT";
        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT:
            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT";
        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT:
            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT";
        default:
            return "Unhandled VkLineRasterizationModeEXT";
    }
}

static inline const char* string_VkIndirectStateFlagBitsNV(VkIndirectStateFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV:
            return "VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV";
        default:
            return "Unhandled VkIndirectStateFlagBitsNV";
    }
}

static inline std::string string_VkIndirectStateFlagsNV(VkIndirectStateFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkIndirectStateFlagBitsNV(static_cast<VkIndirectStateFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkIndirectStateFlagBitsNV(static_cast<VkIndirectStateFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkIndirectCommandsTokenTypeNV(VkIndirectCommandsTokenTypeNV input_value)
{
    switch (input_value)
    {
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV";
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV";
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV";
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV";
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV";
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV";
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV";
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV:
            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV";
        default:
            return "Unhandled VkIndirectCommandsTokenTypeNV";
    }
}

static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsNV(VkIndirectCommandsLayoutUsageFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV:
            return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV";
        case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV:
            return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV";
        case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV:
            return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV";
        default:
            return "Unhandled VkIndirectCommandsLayoutUsageFlagBitsNV";
    }
}

static inline std::string string_VkIndirectCommandsLayoutUsageFlagsNV(VkIndirectCommandsLayoutUsageFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsNV(static_cast<VkIndirectCommandsLayoutUsageFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsNV(static_cast<VkIndirectCommandsLayoutUsageFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkDeviceMemoryReportEventTypeEXT(VkDeviceMemoryReportEventTypeEXT input_value)
{
    switch (input_value)
    {
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT:
            return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT";
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT:
            return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT";
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT:
            return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT";
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT:
            return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT";
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT:
            return "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT";
        default:
            return "Unhandled VkDeviceMemoryReportEventTypeEXT";
    }
}

static inline const char* string_VkDeviceDiagnosticsConfigFlagBitsNV(VkDeviceDiagnosticsConfigFlagBitsNV input_value)
{
    switch (input_value)
    {
        case VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV:
            return "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV";
        case VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV:
            return "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV";
        case VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV:
            return "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV";
        case VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV:
            return "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV";
        default:
            return "Unhandled VkDeviceDiagnosticsConfigFlagBitsNV";
    }
}

static inline std::string string_VkDeviceDiagnosticsConfigFlagsNV(VkDeviceDiagnosticsConfigFlagsNV input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkDeviceDiagnosticsConfigFlagBitsNV(static_cast<VkDeviceDiagnosticsConfigFlagBitsNV>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkDeviceDiagnosticsConfigFlagBitsNV(static_cast<VkDeviceDiagnosticsConfigFlagBitsNV>(0)));
    return ret;
}

static inline const char* string_VkGraphicsPipelineLibraryFlagBitsEXT(VkGraphicsPipelineLibraryFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT:
            return "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT";
        case VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT:
            return "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT";
        case VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT:
            return "VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT";
        case VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT:
            return "VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT";
        default:
            return "Unhandled VkGraphicsPipelineLibraryFlagBitsEXT";
    }
}

static inline std::string string_VkGraphicsPipelineLibraryFlagsEXT(VkGraphicsPipelineLibraryFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkGraphicsPipelineLibraryFlagBitsEXT(static_cast<VkGraphicsPipelineLibraryFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkGraphicsPipelineLibraryFlagBitsEXT(static_cast<VkGraphicsPipelineLibraryFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkFragmentShadingRateTypeNV(VkFragmentShadingRateTypeNV input_value)
{
    switch (input_value)
    {
        case VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV:
            return "VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV";
        case VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV:
            return "VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV";
        default:
            return "Unhandled VkFragmentShadingRateTypeNV";
    }
}

static inline const char* string_VkFragmentShadingRateNV(VkFragmentShadingRateNV input_value)
{
    switch (input_value)
    {
        case VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV:
            return "VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV";
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV:
            return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV";
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV:
            return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV";
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV:
            return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV";
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV:
            return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV";
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV:
            return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV";
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV:
            return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV";
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV:
            return "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV";
        case VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV:
            return "VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV";
        case VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV:
            return "VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV";
        case VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV:
            return "VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV";
        case VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV:
            return "VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV";
        default:
            return "Unhandled VkFragmentShadingRateNV";
    }
}

static inline const char* string_VkAccelerationStructureMotionInstanceTypeNV(VkAccelerationStructureMotionInstanceTypeNV input_value)
{
    switch (input_value)
    {
        case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV:
            return "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV";
        case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV:
            return "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV";
        case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV:
            return "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV";
        default:
            return "Unhandled VkAccelerationStructureMotionInstanceTypeNV";
    }
}

static inline const char* string_VkImageCompressionFlagBitsEXT(VkImageCompressionFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_COMPRESSION_DEFAULT_EXT:
            return "VK_IMAGE_COMPRESSION_DEFAULT_EXT";
        case VK_IMAGE_COMPRESSION_DISABLED_EXT:
            return "VK_IMAGE_COMPRESSION_DISABLED_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT";
        default:
            return "Unhandled VkImageCompressionFlagBitsEXT";
    }
}

static inline std::string string_VkImageCompressionFlagsEXT(VkImageCompressionFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkImageCompressionFlagBitsEXT(static_cast<VkImageCompressionFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkImageCompressionFlagBitsEXT(static_cast<VkImageCompressionFlagBitsEXT>(0)));
    return ret;
}

static inline const char* string_VkImageCompressionFixedRateFlagBitsEXT(VkImageCompressionFixedRateFlagBitsEXT input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT";
        case VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT:
            return "VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT";
        default:
            return "Unhandled VkImageCompressionFixedRateFlagBitsEXT";
    }
}

static inline std::string string_VkImageCompressionFixedRateFlagsEXT(VkImageCompressionFixedRateFlagsEXT input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkImageCompressionFixedRateFlagBitsEXT(static_cast<VkImageCompressionFixedRateFlagBitsEXT>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkImageCompressionFixedRateFlagBitsEXT(static_cast<VkImageCompressionFixedRateFlagBitsEXT>(0)));
    return ret;
}


#ifdef VK_USE_PLATFORM_FUCHSIA

static inline const char* string_VkImageConstraintsInfoFlagBitsFUCHSIA(VkImageConstraintsInfoFlagBitsFUCHSIA input_value)
{
    switch (input_value)
    {
        case VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA:
            return "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA";
        case VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA:
            return "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA";
        case VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA:
            return "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA";
        case VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA:
            return "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA";
        case VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA:
            return "VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA";
        default:
            return "Unhandled VkImageConstraintsInfoFlagBitsFUCHSIA";
    }
}

static inline std::string string_VkImageConstraintsInfoFlagsFUCHSIA(VkImageConstraintsInfoFlagsFUCHSIA input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkImageConstraintsInfoFlagBitsFUCHSIA(static_cast<VkImageConstraintsInfoFlagBitsFUCHSIA>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkImageConstraintsInfoFlagBitsFUCHSIA(static_cast<VkImageConstraintsInfoFlagBitsFUCHSIA>(0)));
    return ret;
}
#endif // VK_USE_PLATFORM_FUCHSIA

static inline const char* string_VkSubpassMergeStatusEXT(VkSubpassMergeStatusEXT input_value)
{
    switch (input_value)
    {
        case VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT:
            return "VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT";
        case VK_SUBPASS_MERGE_STATUS_MERGED_EXT:
            return "VK_SUBPASS_MERGE_STATUS_MERGED_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT";
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT:
            return "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT";
        default:
            return "Unhandled VkSubpassMergeStatusEXT";
    }
}

static inline const char* string_VkBuildAccelerationStructureModeKHR(VkBuildAccelerationStructureModeKHR input_value)
{
    switch (input_value)
    {
        case VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR";
        case VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR:
            return "VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR";
        default:
            return "Unhandled VkBuildAccelerationStructureModeKHR";
    }
}

static inline const char* string_VkAccelerationStructureBuildTypeKHR(VkAccelerationStructureBuildTypeKHR input_value)
{
    switch (input_value)
    {
        case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR:
            return "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR";
        case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR:
            return "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR";
        case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR:
            return "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR";
        default:
            return "Unhandled VkAccelerationStructureBuildTypeKHR";
    }
}

static inline const char* string_VkAccelerationStructureCreateFlagBitsKHR(VkAccelerationStructureCreateFlagBitsKHR input_value)
{
    switch (input_value)
    {
        case VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR:
            return "VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR";
        case VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV:
            return "VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV";
        default:
            return "Unhandled VkAccelerationStructureCreateFlagBitsKHR";
    }
}

static inline std::string string_VkAccelerationStructureCreateFlagsKHR(VkAccelerationStructureCreateFlagsKHR input_value)
{
    std::string ret;
    int index = 0;
    while(input_value) {
        if (input_value & 1) {
            if( !ret.empty()) ret.append("|");
            ret.append(string_VkAccelerationStructureCreateFlagBitsKHR(static_cast<VkAccelerationStructureCreateFlagBitsKHR>(1U << index)));
        }
        ++index;
        input_value >>= 1;
    }
    if( ret.empty()) ret.append(string_VkAccelerationStructureCreateFlagBitsKHR(static_cast<VkAccelerationStructureCreateFlagBitsKHR>(0)));
    return ret;
}

static inline const char* string_VkAccelerationStructureCompatibilityKHR(VkAccelerationStructureCompatibilityKHR input_value)
{
    switch (input_value)
    {
        case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR:
            return "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR";
        case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR:
            return "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR";
        default:
            return "Unhandled VkAccelerationStructureCompatibilityKHR";
    }
}

static inline const char* string_VkShaderGroupShaderKHR(VkShaderGroupShaderKHR input_value)
{
    switch (input_value)
    {
        case VK_SHADER_GROUP_SHADER_ANY_HIT_KHR:
            return "VK_SHADER_GROUP_SHADER_ANY_HIT_KHR";
        case VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR:
            return "VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR";
        case VK_SHADER_GROUP_SHADER_GENERAL_KHR:
            return "VK_SHADER_GROUP_SHADER_GENERAL_KHR";
        case VK_SHADER_GROUP_SHADER_INTERSECTION_KHR:
            return "VK_SHADER_GROUP_SHADER_INTERSECTION_KHR";
        default:
            return "Unhandled VkShaderGroupShaderKHR";
    }
}

static inline const char * GetPhysDevFeatureString(uint32_t index) {
    const char * IndexToPhysDevFeatureString[] = {
        "robustBufferAccess",
        "fullDrawIndexUint32",
        "imageCubeArray",
        "independentBlend",
        "geometryShader",
        "tessellationShader",
        "sampleRateShading",
        "dualSrcBlend",
        "logicOp",
        "multiDrawIndirect",
        "drawIndirectFirstInstance",
        "depthClamp",
        "depthBiasClamp",
        "fillModeNonSolid",
        "depthBounds",
        "wideLines",
        "largePoints",
        "alphaToOne",
        "multiViewport",
        "samplerAnisotropy",
        "textureCompressionETC2",
        "textureCompressionASTC_LDR",
        "textureCompressionBC",
        "occlusionQueryPrecise",
        "pipelineStatisticsQuery",
        "vertexPipelineStoresAndAtomics",
        "fragmentStoresAndAtomics",
        "shaderTessellationAndGeometryPointSize",
        "shaderImageGatherExtended",
        "shaderStorageImageExtendedFormats",
        "shaderStorageImageMultisample",
        "shaderStorageImageReadWithoutFormat",
        "shaderStorageImageWriteWithoutFormat",
        "shaderUniformBufferArrayDynamicIndexing",
        "shaderSampledImageArrayDynamicIndexing",
        "shaderStorageBufferArrayDynamicIndexing",
        "shaderStorageImageArrayDynamicIndexing",
        "shaderClipDistance",
        "shaderCullDistance",
        "shaderFloat64",
        "shaderInt64",
        "shaderInt16",
        "shaderResourceResidency",
        "shaderResourceMinLod",
        "sparseBinding",
        "sparseResidencyBuffer",
        "sparseResidencyImage2D",
        "sparseResidencyImage3D",
        "sparseResidency2Samples",
        "sparseResidency4Samples",
        "sparseResidency8Samples",
        "sparseResidency16Samples",
        "sparseResidencyAliased",
        "variableMultisampleRate",
        "inheritedQueries",
    };

    return IndexToPhysDevFeatureString[index];
}

static inline bool IsDuplicatePnext(VkStructureType input_value)
{
    switch (input_value)
    {
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
            return true;
        default:
            return false;
    }
}
